diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,46 @@ # Changelog +## 0.3.0.0 + +- Updated the `Transition` class definition with a defaulted internal dense + backend method and relaxed finite-state constraints on cached queries. + Existing custom instances can continue to implement only `transitionLaw`. + The major version bump accounts for these class and signature changes. + +- Updated the package maintainer contact email. +- Made `evolveVectorN` choose between repeated matrix-vector multiplication + and matrix powering, avoiding unnecessary full matrix powers for moderate + step counts. +- Added `simulateMatrix`, which lazily prepares and shares cumulative sampling + rows during a trajectory instead of rebuilding map-backed distributions on + every transition. +- Reworked the GTH stationary solver around strict indexed mutable-vector + loops, substantially reducing allocation in large irreducible classes. +- Cached complete communicating-class classifications lazily in transition + matrices, allowing repeated whole-chain queries to share public results. +- Split warm-class benchmarks into cached access and fully consumed cases, + with equivalent state traversal in Haskell and Python. +- Reduced support-graph construction allocation by scanning the matrix's + storable row-major vector directly instead of materialising boxed row and + value lists first. +- Centralised adaptive dense finite-horizon paths shared by finite-time, + hitting-time, return-time, and visit-count analyses. Branching + transition-matrix rows use BLAS-backed vector propagation, while + deterministic matrices and general locally finite kernels retain the + existing sparse recurrences and public API. +- Added a batched absorption-probability matrix operation that solves every + recurrent destination with one shared factorisation, while scalar + absorption queries now solve their single right-hand side directly instead + of constructing the complete fundamental inverse. +- Reduced shared @(I - Q)@ solve overhead by proving well-conditioned DTMC + systems from an extra right-hand side in the existing LU factorisation, + avoiding a separate singular-value decomposition except near the numerical + rejection threshold. Matrix validation and residual norms now scan + unboxed storage rather than materialising boxed element lists. +- Represented dense bounded-hitting targets by their canonical indices rather + than two full floating-point masks, reducing target-mass collection to the + target coordinates and clearing only those coordinates after each step. + ## 0.2.0.0 First Hackage release. diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -26,7 +26,7 @@ Add the package to your Cabal file: ```cabal -build-depends: dtmc ^>=0.2.0.0 +build-depends: dtmc ^>=0.3.0.0 ``` The package requires GHC 9.6 or newer and a BLAS/LAPACK implementation for diff --git a/benchmark/README.md b/benchmark/README.md new file mode 100644 --- /dev/null +++ b/benchmark/README.md @@ -0,0 +1,174 @@ +# `dtmc` versus PyDTMC benchmark + +This directory contains a public-API benchmark of `dtmc` against PyDTMC +9.0.0. It deliberately measures equivalent mathematical results rather than +similarly named functions. + +## Quick start + +Python 3.12, GHC 9.10.3, Cabal, and a BLAS/LAPACK installation are required. +Using another compiler supported by `dtmc` requires regenerating the Cabal +freeze file and records a different environment. + +Haskell benchmark dependencies are pinned by `cabal.project.freeze`; direct +and transitive Python package versions are pinned by +`python/requirements.lock` and captured with the results. + +```console +python3 benchmark/run.py all --mode smoke +``` + +The smoke workflow creates an isolated Python environment, builds the Haskell +benchmark, generates five 10-state fixtures, verifies deterministic outputs, +runs short Criterion and pyperf measurements, aggregates them, and creates +plots. The full reproducible experiment is: + +```console +python3 benchmark/run.py all --mode full +``` + +The main overview is `ratio-summary.csv`; ratios above one favor `dtmc`. + +The full suite is intentionally expensive. Individual phases are available as +`bootstrap`, `generate`, `verify`, `benchmark`, `profile`, and `analyse` +commands. `profile` records Haskell RTS allocation/GC statistics and Python +`cProfile` data for stationary, hitting, committor, mean-recurrence, bounded +visit, and long-simulation representatives. + +## Fairness contract + +- Both implementations read the same little-endian IEEE-754 payload. SHA-256 + hashes live in the generated `data/generated/manifest.json`; input decoding + is not timed. The committed experiment definition is `data/spec.json`. +- Inputs are valid stochastic matrices away from each library's validation + tolerance. Invalid-input behavior is not compared. +- Finite matrices are dense in both libraries. The `low-outdegree` family has + exact zeros but is not described as sparse storage. +- Construction measures each public constructor as defined. PyDTMC eagerly + builds its NetworkX graph, while `dtmc` leaves its support graph lazy. +- `structure/classes-lifecycle` measures construction through the first SCC + answer. `classes-cold` excludes transition-matrix construction and graph + materialization. `classes-warm/access` measures cached property access; + `classes-warm/consumed` traverses every returned state in both libraries. +- Cached PyDTMC properties and lazy `dtmc` graph/classification fields are + recreated for each cold sample. Fixture setup is excluded from those + samples. +- `hitting-*/cold-all-states` computes and consumes the complete all-state + result. The `dtmc`-only `hitting-*/warm-lookup` rows measure one scalar + lookup through the same partially applied function after its shared solve + has been forced; PyDTMC has no equivalent reusable lookup object. +- Bounded return cases ask for the probability of returning to state zero by + step 10 or 100. PyDTMC exposes the individual first-passage masses, so its + timed adapter sums them. Bounded visit cases ask for the expected visits to + the first manifest target, starting in state zero. PyDTMC's reward horizon + is one less because it includes both time zero and the named final step. +- Scalar finite-time cases use state zero as the source and the first manifest + target as the destination. Timed-observation cases start from the complete + manifest initial distribution. PyDTMC's redistribution result is indexed at + the destination so both sides return and consume one scalar. +- Bounded hitting cases start from state zero and use the complete manifest + target set. They compare exact, at-most, and greater-than events at steps 10 + and 100. PyDTMC computes first passage to each destination separately, so + its fixture makes every target absorbing before calling the public + multi-target operation. This leaves first-hit probabilities unchanged while + making the target events disjoint. The matrix transformation and chain + construction are outside the timed operation. The adapters then select the + last mass, sum the masses, or subtract their sum from one respectively. +- Pyperf records 30 fresh full-operation values per normal cell (three worker + processes, ten values each). Warm-cache lookups are internally batched; + Criterion uses its calibrated sample schedule. Smoke mode intentionally uses + fewer values and is not performance evidence. +- Numeric results are consumed with deterministic checksums. This prevents + Haskell laziness from turning a benchmark into wrapper construction alone. +- BLAS thread environment variables are fixed to one. The actual Haskell and + NumPy linkage is captured in `results/environment.json`. +- Simulation compares throughput and validates behavior statistically; equal + seeds do not imply equal paths because the RNG algorithms differ. PyDTMC's + public simulation call creates its generator during the timed operation; + `dtmc` receives the generator required by its public API before timing. The + `dtmc` case uses its public matrix-specialized API; its lazy row preparation + and cache are created inside the timed operation. + +## Dataset families + +- `dense`: every entry is positive; irreducible and aperiodic. +- `low-outdegree`: four or fewer exact-positive entries per row, including a + self-loop and the next ring state; irreducible and aperiodic. +- `absorbing`: two singleton absorbing states and a transient dense block from + which absorption is certain. +- `reducible`: a transient communicating block feeding two closed irreducible + classes, with probabilities kept away from either library's near-zero + threshold. +- `periodic`: a deterministic directed cycle, included so period and cyclic + decomposition do nontrivial work. + +Full runs use sizes 10, 25, 50, 100, 250, 500, and 1000 with seeds 1729, 2718, +and 31415. Cubic operations stop at 500, occupation matrices at 250, bounded +finite-horizon cases at 100, and dense NetworkX structural cases at 500. These +caps are symmetric. + +## Measured mappings + +| Benchmark | `dtmc` | PyDTMC | +|---|---|---| +| `construction/public-consumed` | `fromRows` | `MarkovChain(P)` | +| `evolution/one-step` | `evolveVector` | `redistribute(1)` | +| `evolution/k-*` | `evolveVectorN` | `redistribute(k)` | +| `finite-time/step` | `stepProbability` | matrix entry lookup | +| `finite-time/n-step/k-*` | `nStepProbability` | point-mass `redistribute(k)` lookup | +| `finite-time/observation/k-*` | `probability [At k target]` | initial-law `redistribute(k)` lookup | +| `power/*` | `power` | `to_nth_order` | +| `structure/classes-*` | `communicatingClasses` | `communicating_classes` | +| `structure/irreducible-*` | `irreducible` | `is_irreducible` | +| `structure/period-*` | `chainPeriod` | `period` | +| `structure/cyclic-classes-*` | `cyclicClasses` | `cyclic_classes` | +| `stationary` | `stationaryDistributions` | `pi` | +| `hitting-probability/cold-all-states` | all-state eventual hitting | `hitting_probabilities` | +| `hitting-time/cold-all-states` | all-state expected hitting | `hitting_times` | +| `hitting/bounded/exact/k-*` | `probabilityGivenInitialState (EqualTo k)` | final `first_passage_probabilities` mass | +| `hitting/bounded/at-most/k-*` | `probabilityGivenInitialState (AtMost k)` | summed `first_passage_probabilities` | +| `hitting/bounded/greater-than/k-*` | `probabilityGivenInitialState (GreaterThan k)` | one minus summed `first_passage_probabilities` | +| `race/forward-committor` | `raceProbabilityGivenInitialState` | `committor_probabilities("forward", ...)` | +| `return/mean-recurrence` | `expectationGivenInitialState` | `mean_recurrence_times` | +| `return/bounded/k-*` | `probabilityGivenInitialState (AtMost k)` | summed `first_passage_probabilities` | +| `visits/bounded-expectation/k-*` | `boundedExpectationGivenInitialState` | `expected_rewards(k - 1, ...)` | +| `fundamental-matrix` | `fundamentalMatrix` | `fundamental_matrix` | +| `absorption-time` | all-state expectation, transient part | `mean_absorption_times` | +| `absorption/probabilities` | `probabilityMatrix` | `absorption_probabilities` | +| `occupation-matrix` | `occupationMatrix` | `mean_number_visits` | +| `simulation/*` | `simulateMatrix` | `simulate` | + +`evolveVectorN` chooses between `k` matrix-vector steps and matrix powering +using the matrix dimension and requested step count; PyDTMC performs `k` +matrix-vector steps. The comparison is a public end-to-end workload, not a +claim that their internal primitives are identical. + +Race/committor and mean-recurrence comparisons use only the dense and +low-outdegree aperiodic irreducible families because PyDTMC returns `None` for +non-ergodic chains. Absorption-probability rows use the manifest absorber order +and canonical transient-state order. + +PyDTMC's `mean_number_visits` excludes the visit at time zero, while +`occupationMatrix` includes it. The Python case therefore adds the identity +matrix to the PyDTMC result. That semantic adapter is included in the public +workload timing and in correctness verification. + +## Correctness + +`benchmark/python/verify.py` compares complete outputs through size 100 by +default. It checks structural equality, exact infinity masks, and numeric +values using `atol=1e-10` and `rtol=1e-8`. It records maximum absolute and +relative discrepancies in `results/verification.json` and exits unsuccessfully +on a mismatch. + +## Interpreting output + +Raw engine output is retained under `results/raw/`. `summary.csv` contains +median, MAD, quartiles, and sample counts. `ratios.csv` reports +`PyDTMC time / dtmc time`, so values above one favor `dtmc`. Do not compare +cached and cold rows or infer sparse-storage performance from low-outdegree +fixtures. The generated SVGs include both runtime scaling and speed-ratio +plots; ratio confidence bands summarize the three deterministic seeds. +Analysis reads only raw JSON files corresponding to datasets in the current +generated manifest. Raw files from another mode are retained but ignored, so a +smoke run can safely follow a full run without deleting the full results. diff --git a/benchmark/REPORT.md b/benchmark/REPORT.md new file mode 100644 --- /dev/null +++ b/benchmark/REPORT.md @@ -0,0 +1,301 @@ +# Benchmark report: dtmc versus PyDTMC 9.0.0 + +## Result + +The full benchmark completed successfully on 14 September 2026. It compares +equivalent public-API workloads in dtmc and PyDTMC 9.0.0 on the same generated +transition matrices. + +Across 932 family-size-operation aggregates: + +- 917 aggregates (98.4%) have a median ratio above one and therefore favour + dtmc. +- 913 aggregates (98.0%) have a complete 95% seed-bootstrap interval above + one. +- 13 aggregates (1.4%) have a complete interval below one and favour PyDTMC. +- 6 aggregates (0.6%) have an interval that crosses one and are inconclusive. +- The unweighted median ratio across all aggregates is 14.52. + +The ratio is: + +~~~text +PyDTMC elapsed time / dtmc elapsed time +~~~ + +A ratio of 14.52 means that PyDTMC took 14.52 times as long as dtmc for that +benchmark case. Ratios below one favour PyDTMC. The overall median gives every +family-size-operation aggregate equal weight. It is a summary of this +benchmark suite, not a prediction that every dtmc operation is 14.52 times +faster. + +The source of truth for these results is +[results/ratio-summary.csv](results/ratio-summary.csv). It contains one +aggregate for each family, size, and operation, calculated from three fixture +seeds. The underlying 2,796 seed-level ratios are in +[results/ratios.csv](results/ratios.csv). + +## Results by operation group + +“Clear” means that the complete bootstrap interval across the three fixture +seeds lies on one side of one. “Inconclusive” means that it crosses one. + +| Operation group | Aggregates | Median ratio | Clear dtmc wins | Clear PyDTMC wins | Inconclusive | +|---|---:|---:|---:|---:|---:| +| Absorption probabilities | 6 | 9.47 | 6 | 0 | 0 | +| Absorption time | 6 | 7.92 | 6 | 0 | 0 | +| Bounded hitting | 120 | 16.34 | 120 | 0 | 0 | +| Bounded return | 40 | 16.76 | 40 | 0 | 0 | +| Bounded visits | 40 | 3.85 | 40 | 0 | 0 | +| Construction | 35 | 16.94 | 35 | 0 | 0 | +| Evolution | 105 | 20.03 | 103 | 0 | 2 | +| Eventual hitting probability | 30 | 2.62 | 29 | 0 | 1 | +| Expected hitting time | 30 | 5.23 | 29 | 0 | 1 | +| Finite-time analysis | 100 | 9.51 | 92 | 6 | 2 | +| Fundamental matrix | 6 | 5.56 | 6 | 0 | 0 | +| Matrix power | 90 | 25.80 | 90 | 0 | 0 | +| Mean recurrence time | 12 | 20.83 | 12 | 0 | 0 | +| Occupation matrix | 10 | 26.49 | 10 | 0 | 0 | +| Race probability | 12 | 15.50 | 12 | 0 | 0 | +| Simulation | 28 | 12.93 | 28 | 0 | 0 | +| Stationary distributions | 30 | 11.94 | 28 | 2 | 0 | +| Structure | 232 | 18.60 | 227 | 5 | 0 | + +The recently optimised bounded-hitting, bounded-return, bounded-visit, +absorption-probability, and mean-recurrence paths all have clear wins in every +aggregate included in the full run. + +## Representative plots + +The plots report the median PyDTMC/dtmc runtime ratio across three fixture +seeds. Values above one favour dtmc, values below one favour PyDTMC, and the +shaded region is the 95% seed-bootstrap interval. + +### Dense one-step evolution + +![Dense one-step evolution speed ratio](results/plots/dense--evolution-one-step--speed-ratio.svg) + +### Exact bounded hitting at 100 steps + +![Absorbing-chain bounded hitting speed ratio](results/plots/absorbing--hitting-bounded-exact-k-100--speed-ratio.svg) + +### Dense expected hitting time + +![Dense expected hitting-time speed ratio](results/plots/dense--hitting-time-cold-all-states--speed-ratio.svg) + +### Known exception: periodic observations at 100 steps + +![Periodic finite-time observation speed ratio](results/plots/periodic--finite-time-observation-k-100--speed-ratio.svg) + +## Cases that favour PyDTMC + +The 13 clear PyDTMC wins are concentrated in three behaviours. + +### Periodic finite-time observations + +The full-initial-distribution observation path is slower on deterministic +periodic chains at sizes 25, 50, and 100. + +| Operation | Size | Ratio | Equivalent PyDTMC advantage | +|---|---:|---:|---:| +| finite-time/observation/k-10 | 25 | 0.601 | 1.66 times faster | +| finite-time/observation/k-10 | 50 | 0.286 | 3.50 times faster | +| finite-time/observation/k-10 | 100 | 0.138 | 7.26 times faster | +| finite-time/observation/k-100 | 25 | 0.275 | 3.64 times faster | +| finite-time/observation/k-100 | 50 | 0.110 | 9.12 times faster | +| finite-time/observation/k-100 | 100 | 0.049 | 20.44 times faster | + +This weakness is specific to timed observations from the complete initial +distribution. The scalar finite-time/n-step comparisons are clear dtmc wins +in all 40 aggregates. + +### Warm cyclic-class access + +Five periodic warm-access aggregates favour PyDTMC: + +| Sizes | Ratio range | Equivalent PyDTMC advantage | +|---|---:|---:| +| 50, 100, 250, 500, and 1000 | 0.890–0.949 | 1.05–1.12 times faster | + +The difference is small but consistent across the three seeds. Cold cyclic +decomposition strongly favours dtmc, so this result concerns repeated access +to an already-computed value rather than the decomposition algorithm. + +### Stationary distributions + +Two 500-state stationary cases favour PyDTMC: + +| Family | Ratio | Equivalent PyDTMC advantage | +|---|---:|---:| +| Periodic | 0.920 | 1.09 times faster | +| Low-outdegree | 0.934 | 1.07 times faster | + +These are narrow losses. The other 28 stationary aggregates clearly favour +dtmc. + +## Inconclusive cases + +Six intervals cross one: + +| Family | Size | Operation | Median ratio | 95% interval | +|---|---:|---|---:|---:| +| Absorbing | 1000 | evolution/k-100 | 0.888 | 0.886–1.081 | +| Low-outdegree | 1000 | evolution/k-100 | 0.968 | 0.924–1.084 | +| Periodic | 10 | finite-time/observation/k-100 | 1.018 | 0.984–1.033 | +| Dense | 25 | finite-time/step | 2.998 | 0.465–3.861 | +| Dense | 25 | hitting-probability/cold-all-states | 1.753 | 0.768–2.081 | +| Dense | 25 | hitting-time/cold-all-states | 3.920 | 0.626–4.101 | + +The median direction alone should not be used to declare a winner in these +cases. + +## Scaling + +Fifty-two family-operation combinations occur at every tested size. Holding +this panel constant avoids comparing a different mixture of operations at +each size. + +| States | Median ratio in common panel | Aggregates favouring dtmc | +|---:|---:|---:| +| 10 | 27.34 | 52 of 52 | +| 25 | 23.72 | 52 of 52 | +| 50 | 18.20 | 51 of 52 | +| 100 | 15.22 | 51 of 52 | +| 250 | 12.81 | 51 of 52 | +| 500 | 11.28 | 51 of 52 | +| 1000 | 9.70 | 49 of 52 | + +dtmc remains faster in nearly every common-panel aggregate at 1000 states, +but its relative advantage generally narrows as the matrices grow. + +The log-log fits in [results/scaling.csv](results/scaling.csv) contain 172 +operation-family pairs with both engines present. The fitted dtmc exponent is +higher in 135 pairs and lower in 37. These finite-range empirical fits are not +proofs of asymptotic complexity. They do indicate that several dtmc paths grow +faster over the tested size range even though they retain a lower absolute +runtime. + +Large-input scaling is therefore a more important optimisation target than +small-operation overhead. The clearest candidates are long evolution, +stationary distributions, and the periodic finite-time observation path. + +## Correctness + +[results/verification.json](results/verification.json) reports: + +- 1,392 successful output comparisons; +- zero failed comparisons; +- a maximum absolute discrepancy of 7.276e-11; and +- configured tolerances of atol=1e-10 and rtol=1e-8. + +One near-zero bounded-hitting result has a maximum relative discrepancy of +one, but its absolute discrepancy is only 1.542e-20; it passes the stated +absolute tolerance. + +Verification checks complete deterministic outputs through 100 states. The 45 +datasets at sizes 250, 500, and 1000 are intentionally skipped by the +verification-size cap. Their timing measurements are present, but this run +does not provide the same element-by-element correctness check at those +sizes. + +## Benchmark scope and method + +The full run uses: + +- five chain families: dense, low-outdegree, absorbing, reducible, and + periodic; +- sizes 10, 25, 50, 100, 250, 500, and 1000; +- deterministic seeds 1729, 2718, and 31415; +- symmetric size caps for cubic, occupation-matrix, and bounded-horizon + operations; and +- public end-to-end operations that return equivalent mathematical results. + +Both implementations read identical binary fixtures, and input decoding is +outside the timed operation. Finite matrices use dense storage in both +libraries. The low-outdegree family tests matrices containing many exact +zeros, not a sparse-storage representation. + +Pyperf records 30 fresh values per normal PyDTMC cell. Criterion uses its +calibrated sampling schedule for dtmc. Each engine's median runtime is first +calculated for each concrete dataset. Seed-level ratios are then grouped by +family, size, and operation. The reported 95% intervals bootstrap the three +seed-level log ratios. They measure variation across those three fixtures; +they do not measure variation across machines or separate overnight runs. + +Some equivalent workloads require documented adapters. Examples include +summing PyDTMC first-passage masses for bounded return, aligning its reward +horizon for bounded visits, and making bounded-hitting targets absorbing +outside the timed region. These mappings are part of the benchmark's fairness +contract and are documented in [README.md](README.md). + +## Environment + +[results/environment.json](results/environment.json) records: + +- commit daf5d56d8b7967ced2274dfee0c73f2bacb997ff; +- Apple M1, arm64; +- macOS 15.6.1; +- GHC 9.10.3; +- optimisation flag -O2, with -threaded and -rtsopts; +- Python 3.13.9; +- PyDTMC 9.0.0; +- NumPy 2.3.1 and SciPy 1.16.1; +- Apple Accelerate BLAS and LAPACK for both engines; and +- single-thread limits for BLAS-related runtimes. + +The working tree contained only untracked benchmark logs and backups when the +environment was captured. + +The benchmark documentation specifies Python 3.12, but this run used Python +3.13.9. This does not invalidate a same-machine comparison in which both +engines use the recorded environment. A publication-oriented reproducibility +run should use the documented Python version or update and justify the +requirement. + +## Limits on interpretation + +The results support a claim that dtmc is faster for almost all tested +public-API workloads on this Apple M1 configuration. They do not establish: + +- identical speedups on Linux, x86-64, or different BLAS implementations; +- a general Haskell-versus-Python language result; +- sparse-matrix performance; +- correctness above 100 states with the same verification coverage; +- performance for operations without equivalent PyDTMC APIs; or +- one universal speedup applicable to every user workload. + +The largest ratios occur in cold structural operations and should not be +presented as typical speedups for the entire library. The 14.52 median is less +sensitive to those large outliers, but it still reflects the operation mix in +this suite. + +## Recommended next work + +1. Profile finite-time/observation on deterministic periodic chains. Its + disadvantage increases sharply with both size and horizon. +2. Profile the 100-step evolution policy at 1000 states. Two families are + currently inconclusive and the empirical scaling trend favours PyDTMC. +3. Inspect warm cyclic-class access only after the larger finite-time issue. + Its loss is stable but small. +4. Repeat a focused subset after each optimisation before committing to + another full run. +5. Run a second full experiment on a quiet Linux x86-64 machine with the + documented Python version before publishing hardware-independent claims. + +## Result files + +- [results/ratio-summary.csv](results/ratio-summary.csv): primary three-seed + comparison. +- [results/ratios.csv](results/ratios.csv): seed-level paired ratios. +- [results/summary.csv](results/summary.csv): per-engine medians, dispersion, + confidence intervals, and sample counts. +- [results/scaling.csv](results/scaling.csv): empirical log-log scaling fits. +- [results/verification.json](results/verification.json): correctness + comparisons. +- [results/environment.json](results/environment.json): compiler, packages, + linkage, flags, commit, and thread controls. +- [results/plots/](results/plots/): selected publication plots. + +The remaining 350 generated plots and the raw Criterion and pyperf output +remain local build artefacts and are intentionally ignored to avoid adding +approximately 15 MB of generated charts and much larger raw timing files to +the repository. diff --git a/benchmark/analyse.py b/benchmark/analyse.py new file mode 100644 --- /dev/null +++ b/benchmark/analyse.py @@ -0,0 +1,315 @@ +#!/usr/bin/env python3 +"""Aggregate Criterion and pyperf JSON into comparable robust statistics.""" + +from __future__ import annotations + +import argparse +import csv +import hashlib +import json +import math +import random +import statistics +from collections import defaultdict +from pathlib import Path +from typing import Any, Iterable + + +ROOT = Path(__file__).resolve().parent +RESULTS = ROOT / "results" + + +def criterion_samples(path: Path) -> Iterable[tuple[str, float]]: + payload = json.loads(path.read_text(encoding="utf-8")) + if ( + isinstance(payload, list) + and len(payload) == 3 + and payload[0] == "criterion" + and isinstance(payload[2], list) + ): + reports = payload[2] + else: + reports = payload if isinstance(payload, list) else payload.get("reports", []) + for report in reports: + name = report.get("reportName") or report.get("name") + measured = report.get("reportMeasured", []) + samples: list[float] = [] + keys = report.get("reportKeys", []) + for measurement in measured: + if isinstance(measurement, dict): + elapsed = measurement.get("measTime", measurement.get("time")) + iterations = measurement.get("measIters", measurement.get("iters", 1)) + if elapsed is not None: + samples.append(float(elapsed) / max(1.0, float(iterations))) + elif isinstance(measurement, list) and keys: + values = dict(zip(keys, measurement)) + elapsed = values.get("time") + iterations = values.get("iters", 1) + if elapsed is not None: + samples.append(float(elapsed) / max(1.0, float(iterations))) + if not samples: + analysis = report.get("reportAnalysis", report.get("analysis", {})) + estimate = analysis.get("anMean", analysis.get("mean", {})) + point = estimate.get("estPoint", estimate.get("point")) if isinstance(estimate, dict) else None + if point is not None: + samples = [float(point)] + for sample in samples: + yield str(name), sample + + +def pyperf_samples(path: Path) -> Iterable[tuple[str, float]]: + payload = json.loads(path.read_text(encoding="utf-8")) + for benchmark in payload.get("benchmarks", []): + metadata = benchmark.get("metadata", {}) + name = metadata.get("name") or benchmark.get("name") + for run in benchmark.get("runs", []): + for value in run.get("values", []): + yield str(name), float(value) + + +def quartiles(values: list[float]) -> tuple[float, float]: + if len(values) < 2: + return values[0], values[0] + cuts = statistics.quantiles(values, n=4, method="inclusive") + return cuts[0], cuts[2] + + +def percentile(values: list[float], probability: float) -> float: + ordered = sorted(values) + position = probability * (len(ordered) - 1) + lower = int(position) + upper = min(lower + 1, len(ordered) - 1) + fraction = position - lower + return ordered[lower] * (1.0 - fraction) + ordered[upper] * fraction + + +def bootstrap_median_interval(values: list[float], seed: int) -> tuple[float, float]: + if len(values) == 1: + return values[0], values[0] + rng = random.Random(seed) + estimates = [ + statistics.median(rng.choices(values, k=len(values))) + for _ in range(2000) + ] + return percentile(estimates, 0.025), percentile(estimates, 0.975) + + +def stable_seed(value: str) -> int: + return int.from_bytes(hashlib.sha256(value.encode("utf-8")).digest()[:8], "big") + + +def summarize(values: list[float], seed_key: str) -> dict[str, float | int]: + median = statistics.median(values) + deviations = [abs(value - median) for value in values] + q1, q3 = quartiles(values) + ci_low, ci_high = bootstrap_median_interval(values, stable_seed(seed_key)) + return { + "median_seconds": median, + "mad_seconds": statistics.median(deviations), + "q1_seconds": q1, + "q3_seconds": q3, + "median_ci95_low_seconds": ci_low, + "median_ci95_high_seconds": ci_high, + "samples": len(values), + } + + +def split_name(name: str, metadata: dict[str, dict[str, Any]]) -> tuple[str, str]: + for dataset in sorted(metadata, key=len, reverse=True): + prefix = dataset + "/" + if name.startswith(prefix): + return dataset, name[len(prefix) :] + raise ValueError(f"benchmark name does not begin with a manifest dataset id: {name}") + + +def active_result_paths( + results: Path, engine: str, datasets: Iterable[str] +) -> Iterable[Path]: + directory = results / "raw" / engine + for dataset in sorted(datasets): + path = directory / f"{dataset}.json" + if path.is_file(): + yield path + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument( + "--data-root", type=Path, default=ROOT / "data" / "generated" + ) + parser.add_argument("--results-root", type=Path, default=RESULTS) + args = parser.parse_args() + data_root = args.data_root.resolve() + results = args.results_root.resolve() + + manifest = json.loads( + (data_root / "manifest.json").read_text(encoding="utf-8") + ) + metadata = {entry["id"]: entry for entry in manifest["datasets"]} + grouped: dict[tuple[str, str, str], list[float]] = defaultdict(list) + + for path in active_result_paths(results, "haskell", metadata): + for name, value in criterion_samples(path): + dataset, operation = split_name(name, metadata) + grouped[("dtmc", dataset, operation)].append(value) + for path in active_result_paths(results, "python", metadata): + for name, value in pyperf_samples(path): + dataset, operation = split_name(name, metadata) + grouped[("pydtmc", dataset, operation)].append(value) + + rows: list[dict[str, Any]] = [] + for (engine, dataset, operation), values in sorted(grouped.items()): + entry = metadata[dataset] + rows.append( + { + "engine": engine, + "dataset": dataset, + "family": entry["family"], + "size": entry["size"], + "seed": entry["seed"], + "operation": operation, + **summarize(values, f"{engine}/{dataset}/{operation}"), + } + ) + + results.mkdir(parents=True, exist_ok=True) + fields = [ + "engine", + "dataset", + "family", + "size", + "seed", + "operation", + "median_seconds", + "mad_seconds", + "q1_seconds", + "q3_seconds", + "median_ci95_low_seconds", + "median_ci95_high_seconds", + "samples", + ] + with (results / "summary.csv").open("w", newline="", encoding="utf-8") as stream: + writer = csv.DictWriter(stream, fieldnames=fields) + writer.writeheader() + writer.writerows(rows) + + by_key = {(row["engine"], row["dataset"], row["operation"]): row for row in rows} + ratios: list[dict[str, Any]] = [] + for row in rows: + if row["engine"] != "dtmc": + continue + peer = by_key.get(("pydtmc", row["dataset"], row["operation"])) + if peer is None: + continue + ratios.append( + { + "dataset": row["dataset"], + "family": row["family"], + "size": row["size"], + "seed": row["seed"], + "operation": row["operation"], + "pydtmc_over_dtmc": peer["median_seconds"] / row["median_seconds"], + } + ) + ratio_fields = ["dataset", "family", "size", "seed", "operation", "pydtmc_over_dtmc"] + with (results / "ratios.csv").open("w", newline="", encoding="utf-8") as stream: + writer = csv.DictWriter(stream, fieldnames=ratio_fields) + writer.writeheader() + writer.writerows(ratios) + + ratio_groups: dict[tuple[str, int, str], list[float]] = defaultdict(list) + for row in ratios: + ratio_groups[(row["family"], int(row["size"]), row["operation"])].append( + float(row["pydtmc_over_dtmc"]) + ) + ratio_summary: list[dict[str, Any]] = [] + for (family, size, operation), values in sorted(ratio_groups.items()): + logs = [math.log(value) for value in values] + log_low, log_high = bootstrap_median_interval( + logs, stable_seed(f"ratio/{family}/{size}/{operation}") + ) + ratio_summary.append( + { + "family": family, + "size": size, + "operation": operation, + "geometric_median_pydtmc_over_dtmc": math.exp(statistics.median(logs)), + "ci95_low": math.exp(log_low), + "ci95_high": math.exp(log_high), + "datasets": len(values), + } + ) + ratio_summary_fields = [ + "family", + "size", + "operation", + "geometric_median_pydtmc_over_dtmc", + "ci95_low", + "ci95_high", + "datasets", + ] + with (results / "ratio-summary.csv").open("w", newline="", encoding="utf-8") as stream: + writer = csv.DictWriter(stream, fieldnames=ratio_summary_fields) + writer.writeheader() + writer.writerows(ratio_summary) + + scaling_points: dict[tuple[str, str, str, int], list[float]] = defaultdict(list) + for row in rows: + scaling_points[ + (row["engine"], row["family"], row["operation"], int(row["size"])) + ].append(float(row["median_seconds"])) + scaling_groups: dict[tuple[str, str, str], list[tuple[int, float]]] = defaultdict(list) + for (engine, family, operation, size), values in scaling_points.items(): + scaling_groups[(engine, family, operation)].append( + (size, statistics.median(values)) + ) + scaling_rows: list[dict[str, Any]] = [] + for (engine, family, operation), points in sorted(scaling_groups.items()): + if len(points) < 3: + continue + points.sort() + xs = [math.log(float(size)) for size, _ in points] + ys = [math.log(seconds) for _, seconds in points] + x_mean = statistics.mean(xs) + y_mean = statistics.mean(ys) + denominator = sum((value - x_mean) ** 2 for value in xs) + slope = sum((x - x_mean) * (y - y_mean) for x, y in zip(xs, ys)) / denominator + intercept = y_mean - slope * x_mean + fitted = [intercept + slope * value for value in xs] + total = sum((value - y_mean) ** 2 for value in ys) + residual = sum((actual - predicted) ** 2 for actual, predicted in zip(ys, fitted)) + scaling_rows.append( + { + "engine": engine, + "family": family, + "operation": operation, + "slope": slope, + "r_squared": 1.0 - residual / total if total > 0 else 1.0, + "minimum_size": points[0][0], + "maximum_size": points[-1][0], + "points": len(points), + } + ) + scaling_fields = [ + "engine", + "family", + "operation", + "slope", + "r_squared", + "minimum_size", + "maximum_size", + "points", + ] + with (results / "scaling.csv").open("w", newline="", encoding="utf-8") as stream: + writer = csv.DictWriter(stream, fieldnames=scaling_fields) + writer.writeheader() + writer.writerows(scaling_rows) + + print( + f"wrote {len(rows)} summaries, {len(ratios)} paired ratios, " + f"and {len(scaling_rows)} scaling fits" + ) + + +if __name__ == "__main__": + main() diff --git a/benchmark/cabal.project b/benchmark/cabal.project new file mode 100644 --- /dev/null +++ b/benchmark/cabal.project @@ -0,0 +1,7 @@ +packages: . + +benchmarks: True +tests: False + +package dtmc + optimization: 2 diff --git a/benchmark/cabal.project.freeze b/benchmark/cabal.project.freeze new file mode 100644 --- /dev/null +++ b/benchmark/cabal.project.freeze @@ -0,0 +1,141 @@ +active-repositories: hackage.haskell.org:merge +constraints: any.Glob ==0.10.2, + any.OneTuple ==0.4.3, + OneTuple +base-ge-4-15 +base-ge-4-16, + any.Only ==0.1, + any.QuickCheck ==2.18.0.0, + QuickCheck -old-random +templatehaskell, + any.StateVar ==1.2.2, + any.aeson ==2.2.5.0, + aeson +ordered-keymap, + any.ansi-terminal ==1.1.5, + ansi-terminal -example, + any.ansi-terminal-types ==1.1.3, + any.array ==0.5.8.0, + any.assoc ==1.1.1, + assoc -tagged, + any.async ==2.2.6, + async -bench -debug-auto-label, + any.attoparsec ==0.14.4, + attoparsec -developer, + any.base ==4.20.2.0, + any.base-compat ==0.15.0, + any.base-compat-batteries ==0.15.0, + any.base-orphans ==0.9.4, + any.bifunctors ==5.6.3, + bifunctors +tagged, + any.binary ==0.8.9.3, + any.binary-orphans ==1.0.6, + binary-orphans +base-ge-4-16 +base-ge-4-17, + any.bitvec ==1.1.6.0, + bitvec +simd, + any.bytestring ==0.12.2.0, + any.cassava ==0.5.4.1, + any.character-ps ==0.1, + any.code-page ==0.2.1, + any.colour ==2.3.7, + any.comonad ==5.0.10, + comonad +containers +distributive +indexed-traversable, + any.containers ==0.7, + any.contravariant ==1.5.6, + contravariant +statevar, + any.criterion ==1.6.5.0, + criterion -embed-data-files -fast, + any.criterion-measurement ==0.2.5.0, + criterion-measurement -fast, + any.data-default ==0.8.0.2, + any.data-default-class ==0.2.0.0, + any.data-fix ==0.3.4, + any.deepseq ==1.5.0.0, + any.dense-linear-algebra ==0.1.0.0, + any.directory ==1.3.8.5, + any.distributive ==0.6.3, + distributive +tagged, + any.dlist ==1.0, + dlist -werror, + any.exceptions ==0.10.9, + any.filepath ==1.5.4.0, + any.finite-typelits ==0.2.1.0, + any.ghc-bignum ==1.3, + any.ghc-boot-th ==9.10.3, + any.ghc-internal ==9.1003.0, + any.ghc-prim ==0.12.0, + any.hashable ==1.5.1.0, + hashable -arch-native -random-initial-seed, + any.hmatrix ==0.20.2, + hmatrix -disable-default-paths -no-random_r -openblas, + any.hsc2hs ==0.68.10, + hsc2hs -in-ghc-tree, + any.indexed-traversable ==0.1.5, + indexed-traversable +base-ge-4-18, + any.indexed-traversable-instances ==0.1.2.1, + any.integer-conversion ==0.1.1, + any.integer-logarithms ==1.0.5, + integer-logarithms -check-bounds +integer-gmp, + any.js-chart ==2.9.4.1, + any.math-functions ==0.3.4.4, + math-functions +system-erf +system-expm1, + any.microstache ==1.0.3.1, + any.mtl ==2.3.1, + any.mwc-random ==0.15.3.0, + mwc-random -benchpapi, + any.network-uri ==2.6.4.2, + any.optparse-applicative ==0.19.0.0, + optparse-applicative +process, + any.os-string ==2.0.7, + any.parallel ==3.3.0.0, + any.parsec ==3.1.18.0, + any.pretty ==1.1.3.6, + any.prettyprinter ==1.7.2, + prettyprinter -buildreadme +text, + any.prettyprinter-ansi-terminal ==1.1.4, + prettyprinter-ansi-terminal +text, + any.primitive ==0.9.1.0, + any.process ==1.6.26.1, + any.random ==1.3.1, + any.rts ==1.0.2, + any.scientific ==0.3.8.1, + scientific -integer-simple, + any.semialign ==1.4, + semialign +semigroupoids, + any.semigroupoids ==6.0.2, + semigroupoids +comonad +containers +contravariant +tagged +unordered-containers, + any.semigroups ==0.20.1, + any.split ==0.2.5, + any.splitmix ==0.1.3.2, + splitmix -optimised-mixer, + any.statistics ==0.16.5.0, + statistics -benchpapi, + any.stm ==2.5.3.1, + any.storable-complex ==0.2.3.0, + any.strict ==0.5.1, + any.tagged ==0.8.10, + tagged +deepseq +template-haskell, + any.tasty ==1.5.4, + tasty +unix, + any.template-haskell ==2.22.0.0, + any.text ==2.1.3, + any.text-iso8601 ==0.1.1.1, + any.text-short ==0.1.6.1, + text-short -asserts, + any.th-abstraction ==0.7.2.0, + any.th-compat ==0.1.7, + any.these ==1.2.1, + any.time ==1.12.2, + any.time-compat ==1.9.9, + any.transformers ==0.6.1.1, + any.transformers-compat ==0.8, + transformers-compat -five +five-three +generic-deriving +mtl, + any.unix ==2.8.7.0, + any.unordered-containers ==0.2.21, + unordered-containers -debug, + any.uuid-types ==1.0.6.1, + any.vector ==0.13.2.0, + vector +boundschecks -internalchecks -unsafechecks -wall, + any.vector-algorithms ==0.9.1.0, + vector-algorithms +bench +boundschecks -internalchecks -llvm -unsafechecks, + any.vector-binary-instances ==0.2.5.2, + any.vector-stream ==0.1.0.1, + any.vector-th-unbox ==0.2.2, + any.witherable ==0.5 +index-state: hackage.haskell.org 2026-08-27T21:15:46Z diff --git a/benchmark/data/generate.py b/benchmark/data/generate.py new file mode 100644 --- /dev/null +++ b/benchmark/data/generate.py @@ -0,0 +1,227 @@ +#!/usr/bin/env python3 +"""Generate byte-identical benchmark inputs for dtmc and PyDTMC. + +Each payload is little-endian float64 data in row-major order. The n*n +transition probabilities are followed by the n coordinates of the initial +distribution. Metadata and SHA-256 digests are stored in manifest.json. +""" + +from __future__ import annotations + +import argparse +import hashlib +import json +from pathlib import Path +from typing import Callable + +import numpy as np + + +DEFAULT_SIZES = (10, 25, 50, 100, 250, 500, 1000) +DEFAULT_SEEDS = (1729, 2718, 31415) +FAMILY_OFFSETS = { + "dense": 10_000_000, + "low-outdegree": 20_000_000, + "absorbing": 30_000_000, + "reducible": 40_000_000, + "periodic": 50_000_000, +} + + +def normalized_integer_weights(rng: np.random.Generator, size: int) -> np.ndarray: + values = rng.integers(1, 1001, size=size, dtype=np.int64).astype(np.float64) + return values / np.sum(values, dtype=np.float64) + + +def make_dense(n: int, rng: np.random.Generator) -> tuple[np.ndarray, list[int], list[int]]: + matrix = np.vstack([normalized_integer_weights(rng, n) for _ in range(n)]) + width = max(1, n // 20) + targets = list(range(n // 2, min(n, n // 2 + width))) + return matrix, targets, [] + + +def make_low_outdegree( + n: int, rng: np.random.Generator +) -> tuple[np.ndarray, list[int], list[int]]: + matrix = np.zeros((n, n), dtype=np.float64) + degree = min(4, n) + for source in range(n): + destinations = {source, (source + 1) % n} + while len(destinations) < degree: + destinations.add(int(rng.integers(0, n))) + ordered = sorted(destinations) + matrix[source, ordered] = normalized_integer_weights(rng, len(ordered)) + width = max(1, n // 20) + targets = list(range(n // 2, min(n, n // 2 + width))) + return matrix, targets, [] + + +def make_absorbing( + n: int, rng: np.random.Generator +) -> tuple[np.ndarray, list[int], list[int]]: + if n < 4: + raise ValueError("absorbing fixtures require at least four states") + absorbing = [n - 2, n - 1] + matrix = np.zeros((n, n), dtype=np.float64) + for source in range(n - 2): + # Every transient row has a positive edge to each absorber, so the + # transient block has spectral radius strictly below one. + matrix[source, :] = normalized_integer_weights(rng, n) + matrix[n - 2, n - 2] = 1.0 + matrix[n - 1, n - 1] = 1.0 + return matrix, absorbing.copy(), absorbing + + +def _closed_ring( + matrix: np.ndarray, + members: list[int], + rng: np.random.Generator, +) -> None: + for offset, source in enumerate(members): + destinations = sorted({source, members[(offset + 1) % len(members)]}) + matrix[source, destinations] = normalized_integer_weights(rng, len(destinations)) + + +def make_reducible( + n: int, rng: np.random.Generator +) -> tuple[np.ndarray, list[int], list[int]]: + if n < 6: + raise ValueError("reducible fixtures require at least six states") + class_size = max(2, n // 10) + transient_count = n - 2 * class_size + class_a = list(range(transient_count, transient_count + class_size)) + class_b = list(range(transient_count + class_size, n)) + matrix = np.zeros((n, n), dtype=np.float64) + + for source in range(transient_count): + # A dense transient SCC avoids exponentially tiny reachability values + # that fall on PyDTMC's internal np.isclose threshold. Threshold-stress + # behavior is intentionally outside this ordinary performance suite. + ordered = list(range(transient_count)) + [class_a[0], class_b[0]] + matrix[source, ordered] = normalized_integer_weights(rng, len(ordered)) + + _closed_ring(matrix, class_a, rng) + _closed_ring(matrix, class_b, rng) + return matrix, class_a, [] + + +def make_periodic( + n: int, rng: np.random.Generator +) -> tuple[np.ndarray, list[int], list[int]]: + del rng + matrix = np.zeros((n, n), dtype=np.float64) + for source in range(n): + matrix[source, (source + 1) % n] = 1.0 + width = max(1, n // 20) + targets = list(range(n // 2, min(n, n // 2 + width))) + return matrix, targets, [] + + +GENERATORS: dict[ + str, Callable[[int, np.random.Generator], tuple[np.ndarray, list[int], list[int]]] +] = { + "dense": make_dense, + "low-outdegree": make_low_outdegree, + "absorbing": make_absorbing, + "reducible": make_reducible, + "periodic": make_periodic, +} + + +def make_initial(n: int, rng: np.random.Generator) -> np.ndarray: + return normalized_integer_weights(rng, n) + + +def dataset_id(family: str, size: int, seed: int) -> str: + return f"{family}-n{size:04d}-s{seed:05d}" + + +def generate(output_dir: Path, sizes: list[int], seeds: list[int]) -> dict[str, object]: + output_dir.mkdir(parents=True, exist_ok=True) + records: list[dict[str, object]] = [] + + for family, family_generator in GENERATORS.items(): + for size in sizes: + for seed in seeds: + stream_seed = FAMILY_OFFSETS[family] + size * 1009 + seed + rng = np.random.Generator(np.random.PCG64(stream_seed)) + matrix, targets, absorbing = family_generator(size, rng) + initial = make_initial(size, rng) + + if matrix.shape != (size, size) or initial.shape != (size,): + raise AssertionError("generator returned an invalid shape") + if not np.all(np.isfinite(matrix)) or not np.all(matrix >= 0.0): + raise AssertionError("generator returned invalid probabilities") + if not np.allclose(matrix.sum(axis=1), 1.0, atol=1e-14, rtol=0.0): + raise AssertionError("matrix rows are not stochastic") + if not np.isclose(initial.sum(), 1.0, atol=1e-14, rtol=0.0): + raise AssertionError("initial distribution is not stochastic") + + identifier = dataset_id(family, size, seed) + file_name = f"{identifier}.f64" + path = output_dir / file_name + payload = np.concatenate((matrix.ravel(order="C"), initial)).astype(" list[int]: + return [int(item) for item in value.split(",") if item] + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument( + "--output-dir", + type=Path, + default=Path(__file__).resolve().parent / "generated", + ) + parser.add_argument("--sizes", default=",".join(map(str, DEFAULT_SIZES))) + parser.add_argument("--seeds", default=",".join(map(str, DEFAULT_SEEDS))) + args = parser.parse_args() + + sizes = parse_csv_ints(args.sizes) + seeds = parse_csv_ints(args.seeds) + if not sizes or any(size < 6 for size in sizes): + parser.error("all sizes must be integers greater than or equal to six") + if not seeds: + parser.error("at least one seed is required") + + manifest = generate(args.output_dir, sizes, seeds) + manifest_path = args.output_dir / "manifest.json" + manifest_path.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8") + print(f"generated {len(manifest['datasets'])} datasets in {args.output_dir}") + print(f"manifest: {manifest_path}") + + +if __name__ == "__main__": + main() diff --git a/benchmark/data/spec.json b/benchmark/data/spec.json new file mode 100644 --- /dev/null +++ b/benchmark/data/spec.json @@ -0,0 +1,21 @@ +{ + "schema_version": 1, + "families": [ + "dense", + "low-outdegree", + "absorbing", + "reducible", + "periodic" + ], + "sizes": [10, 25, 50, 100, 250, 500, 1000], + "seeds": [1729, 2718, 31415], + "power_exponents": [2, 10, 100], + "evolution_steps": [1, 10, 100], + "bounded_steps": [10, 100], + "simulation_steps": [10000, 100000], + "verification_maximum_size": 100, + "numeric_tolerances": { + "absolute": 1e-10, + "relative": 1e-8 + } +} diff --git a/benchmark/haskell/Cases.hs b/benchmark/haskell/Cases.hs new file mode 100644 --- /dev/null +++ b/benchmark/haskell/Cases.hs @@ -0,0 +1,573 @@ +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TypeApplications #-} + +module Cases (benchmarksFor) where + +import Control.DeepSeq (NFData (rnf)) +import Control.Exception (evaluate) +import Criterion.Main +import Data.Finite (Finite) +import Data.Proxy (Proxy (Proxy)) +import Data.Vector.Unboxed qualified as U +import Dataset +import Dtmc.Analysis.Absorption qualified as Absorption +import Dtmc.Analysis.Classification qualified as Classification +import Dtmc.Analysis.Event (DiscreteEvent (AtMost, EqualTo, GreaterThan)) +import Dtmc.Analysis.FiniteTime qualified as FiniteTime +import Dtmc.Analysis.HittingTime qualified as Hitting +import Dtmc.Analysis.ReturnTime qualified as Return +import Dtmc.Analysis.Stationary qualified as Stationary +import Dtmc.Analysis.VisitCount qualified as VisitCount +import Dtmc.Distribution.Vector qualified as Vector +import Dtmc.Dynamics qualified as Dynamics +import Dtmc.Simulation qualified as Simulation +import Dtmc.State (finiteStates) +import Dtmc.Transition.Matrix qualified as Matrix +import Force +import GHC.Exts (RealWorld) +import GHC.TypeNats (KnownNat) +import Numeric.Natural (Natural) +import System.Random.MWC qualified as MWC + +newtype Prepared n = Prepared {unPrepared :: Matrix.TransitionMatrix (Finite n)} + +instance NFData (Prepared n) where + rnf (Prepared matrix) = checksumMatrix matrix `seq` () + +data PreparedDynamics n = PreparedDynamics + { dynamicsMatrix :: Matrix.TransitionMatrix (Finite n) + , dynamicsInitial :: Vector.DistributionVector (Finite n) + } + +instance NFData (PreparedDynamics n) where + rnf prepared = + checksumMatrix (dynamicsMatrix prepared) + `seq` checksumVector (dynamicsInitial prepared) + `seq` () + +newtype PreparedGen = PreparedGen {unPreparedGen :: MWC.Gen RealWorld} + +instance NFData PreparedGen where + rnf (PreparedGen generator) = generator `seq` () + +data PreparedScalarLookup n = PreparedScalarLookup + { scalarLookup :: Finite n -> Double + , scalarLookupState :: Finite n + } + +instance NFData (PreparedScalarLookup n) where + rnf prepared = + scalarLookup prepared + `seq` scalarLookupState prepared + `seq` () + +benchmarksFor :: + forall n. + (KnownNat n) => + Proxy n -> + FilePath -> + Entry -> + Benchmark +benchmarksFor _ dataRoot entry = + env (loadDataset @n dataRoot entry) $ \dataset -> + bgroup + (entryId entry) + ( commonBenchmarks entry dataset + ++ finiteTimeBenchmarks entry dataset + ++ boundedHittingBenchmarks entry dataset + ++ absorptionBenchmarks entry dataset + ++ occupationBenchmarks entry dataset + ++ returnBenchmarks entry dataset + ++ visitBenchmarks entry dataset + ++ simulationBenchmarks entry dataset + ) + +commonBenchmarks :: forall n. (KnownNat n) => Entry -> Dataset n -> [Benchmark] +commonBenchmarks entry dataset = + [ bgroup + "construction" + [ bench "public-consumed" $ + nf (checksumMatrix . matrixFromRows @n) (datasetRows dataset) + ] + , env (preparedDynamics dataset) $ \ ~(PreparedDynamics matrix initial) -> + bgroup + "evolution" + [ bench "one-step" $ + nf (checksumVector . Dynamics.evolveVector initial) matrix + , bench "k-10" $ + nf (checksumVector . Dynamics.evolveVectorN 10 initial) matrix + , bench "k-100" $ + nf (checksumVector . Dynamics.evolveVectorN 100 initial) matrix + ] + ] + ++ powerCases + ++ structureCases + ++ numericalCases + where + targets = datasetTargets dataset + competing = datasetCompeting dataset + powerCases + | entrySize entry > 500 = [] + | otherwise = + [ env (preparedMatrix dataset) $ \ ~(Prepared matrix) -> + bgroup + "power" + [ bench (show powerValue) $ + nf (checksumMatrix . Matrix.power powerValue) matrix + | powerValue <- [2, 10, 100] + ] + ] + structureCases + | entryFamily entry == "dense" && entrySize entry > 500 = [] + | otherwise = + [ bgroup + "structure" + ( [ bench "classes-lifecycle" $ + nf (classesLifecycle (Proxy @n)) (datasetRows dataset) + , bench "classes-cold" $ + perRunEnv (preparedGraph dataset) $ \prepared -> + evaluate $! + checksumClasses + (Classification.communicatingClasses (unPrepared prepared)) + , env (preparedWarmClasses dataset) $ \ ~(Prepared matrix) -> + bgroup + "classes-warm" + [ bench "access" $ + whnf Classification.communicatingClasses matrix + , bench "consumed" $ + nf + (checksumClasses . Classification.communicatingClasses) + matrix + ] + , bench "irreducible-cold" $ + perRunEnv (preparedGraph dataset) $ \prepared -> + evaluate $! Classification.irreducible (unPrepared prepared) + , env (preparedWarmIrreducible dataset) $ \ ~(Prepared matrix) -> + bench "irreducible-warm" $ + nf Classification.irreducible matrix + ] + ++ periodicStructureCases + ) + ] + where + periodicStructureCases + | entryFamily entry /= "periodic" = [] + | otherwise = + [ bench "period-cold" $ + perRunEnv (preparedGraph dataset) $ \prepared -> + evaluate $! + checksumPeriod + (Classification.chainPeriod (unPrepared prepared)) + , env (preparedWarmPeriod dataset) $ \ ~(Prepared matrix) -> + bench "period-warm" $ + nf (checksumPeriod . Classification.chainPeriod) matrix + , bench "cyclic-classes-cold" $ + perRunEnv (preparedGraph dataset) $ \prepared -> + evaluate $! + checksumCyclicClasses + (Classification.cyclicClasses (unPrepared prepared)) + , env (preparedWarmCyclicClasses dataset) $ \ ~(Prepared matrix) -> + bench "cyclic-classes-warm" $ + nf + (checksumCyclicClasses . Classification.cyclicClasses) + matrix + ] + numericalCases + | entrySize entry > 500 = [] + | otherwise = + [ bench "stationary" $ + perRunEnv (preparedGraph dataset) $ \prepared -> + evaluate $! + checksumStationary + ( eitherOrFail + (Stationary.stationaryDistributions (unPrepared prepared)) + ) + , bgroup + "hitting-probability" + [ bench "cold-all-states" $ + perRunEnv (preparedGraph dataset) $ \prepared -> + evaluate $! + hittingProbabilityChecksum targets (unPrepared prepared) + , env (preparedWarmHittingProbability dataset) $ \prepared -> + bench "warm-lookup" $ + whnf + (\fixture -> scalarLookup fixture (scalarLookupState fixture)) + prepared + ] + , bgroup + "hitting-time" + [ bench "cold-all-states" $ + perRunEnv (preparedGraph dataset) $ \prepared -> + evaluate $! + hittingExpectationChecksum targets (unPrepared prepared) + , env (preparedWarmHittingExpectation dataset) $ \prepared -> + bench "warm-lookup" $ + whnf + (\fixture -> scalarLookup fixture (scalarLookupState fixture)) + prepared + ] + ] + ++ raceCases + where + raceCases + | entryFamily entry `notElem` ["dense", "low-outdegree"] = [] + | otherwise = + [ bench "race/forward-committor" $ + perRunEnv (preparedGraph dataset) $ \prepared -> + evaluate $! + raceProbabilityChecksum + targets + competing + (unPrepared prepared) + ] + +finiteTimeBenchmarks :: forall n. (KnownNat n) => Entry -> Dataset n -> [Benchmark] +finiteTimeBenchmarks entry dataset + | entrySize entry > 100 = [] + | otherwise = + [ bench "finite-time/step" $ + perRunEnv (preparedMatrix dataset) $ \prepared -> + evaluate $! + FiniteTime.stepProbability + (unPrepared prepared) + source + target + ] + ++ [ bench ("finite-time/n-step/k-" ++ show steps) $ + perRunEnv (preparedMatrix dataset) $ \prepared -> + evaluate $! + FiniteTime.nStepProbability + steps + (unPrepared prepared) + source + target + | steps <- [10, 100] + ] + ++ [ bench ("finite-time/observation/k-" ++ show time) $ + perRunEnv (preparedDynamics dataset) $ \prepared -> + evaluate $! + FiniteTime.probability + (dynamicsInitial prepared) + (dynamicsMatrix prepared) + [FiniteTime.At time target] + | time <- [10, 100] + ] + where + source = benchmarkState @n + target = benchmarkTarget dataset + +boundedHittingBenchmarks :: forall n. (KnownNat n) => Entry -> Dataset n -> [Benchmark] +boundedHittingBenchmarks entry dataset + | entrySize entry > 100 = [] + | otherwise = + [ bench ("hitting/bounded/" ++ label ++ "/k-" ++ show horizon) $ + perRunEnv (preparedMatrix dataset) $ \prepared -> + evaluate $! + Hitting.probabilityGivenInitialState + (event horizon) + (unPrepared prepared) + isTarget + initial + | (label, event) <- + [ ("exact", EqualTo) + , ("at-most", AtMost) + , ("greater-than", GreaterThan) + ] + , horizon <- [10, 100] + ] + where + initial = benchmarkState @n + targets = datasetTargets dataset + isTarget state = state `elem` targets + +absorptionBenchmarks :: forall n. (KnownNat n) => Entry -> Dataset n -> [Benchmark] +absorptionBenchmarks entry dataset + | entryFamily entry /= "absorbing" = [] + | entrySize entry > 500 = [] + | otherwise = + [ bench "fundamental-matrix" $ + perRunEnv (preparedGraph dataset) $ \prepared -> + evaluate $! + checksumFundamental + ( eitherOrFail + (Absorption.fundamentalMatrix (unPrepared prepared)) + ) + , bench "absorption-time" $ + perRunEnv (preparedGraph dataset) $ \prepared -> + evaluate $! absorptionExpectationChecksum (unPrepared prepared) + , bench "absorption/probabilities" $ + perRunEnv (preparedGraph dataset) $ \prepared -> + evaluate $! + absorptionProbabilityChecksum (unPrepared prepared) + ] + +occupationBenchmarks :: forall n. (KnownNat n) => Entry -> Dataset n -> [Benchmark] +occupationBenchmarks entry dataset + | entryFamily entry `notElem` ["absorbing", "reducible"] = [] + | entrySize entry > 250 = [] + | otherwise = + [ bench "occupation-matrix" $ + perRunEnv (preparedGraph dataset) $ \prepared -> + evaluate $! + checksumOccupation + ( eitherOrFail + (VisitCount.occupationMatrix (unPrepared prepared)) + ) + ] + +returnBenchmarks :: forall n. (KnownNat n) => Entry -> Dataset n -> [Benchmark] +returnBenchmarks entry dataset = meanRecurrenceCase ++ boundedCases + where + meanRecurrenceCase + | entryFamily entry `notElem` ["dense", "low-outdegree"] = [] + | entrySize entry > 500 = [] + | otherwise = + [ bench "return/mean-recurrence" $ + perRunEnv (preparedGraph dataset) $ \prepared -> + evaluate $! returnExpectationChecksum (unPrepared prepared) + ] + boundedCases + | entrySize entry > 100 = [] + | otherwise = + [ bench ("return/bounded/k-" ++ show bound) $ + perRunEnv (preparedMatrix dataset) $ \prepared -> + evaluate $! + Return.probabilityGivenInitialState + (AtMost bound) + (unPrepared prepared) + (benchmarkState @n) + | bound <- [10, 100] + ] + +visitBenchmarks :: forall n. (KnownNat n) => Entry -> Dataset n -> [Benchmark] +visitBenchmarks entry dataset + | entrySize entry > 100 = [] + | otherwise = + [ bench ("visits/bounded-expectation/k-" ++ show bound) $ + perRunEnv (preparedMatrix dataset) $ \prepared -> + evaluate $! + VisitCount.boundedExpectationGivenInitialState + bound + (benchmarkState @n) + (unPrepared prepared) + (== target) + | bound <- [10, 100] + ] + where + target = benchmarkTarget dataset + +simulationBenchmarks :: forall n. (KnownNat n) => Entry -> Dataset n -> [Benchmark] +simulationBenchmarks entry dataset + | entryFamily entry `notElem` ["dense", "low-outdegree"] = [] + | otherwise = + [ env (preparedMatrix dataset) $ \ ~(Prepared matrix) -> + bgroup + "simulation" + [ bench (show transitions) $ + perRunEnv (preparedGenerator (entrySeed entry)) $ \generator -> + simulationChecksum + transitions + matrix + (unPreparedGen generator) + | transitions <- [10000, 100000] + ] + ] + +matrixFromRows :: forall n. (KnownNat n) => [[Double]] -> Matrix.TransitionMatrix (Finite n) +matrixFromRows = eitherOrFail . Matrix.fromRows + +vectorFromWeights :: forall n. (KnownNat n) => [Double] -> Vector.DistributionVector (Finite n) +vectorFromWeights = eitherOrFail . Vector.fromList + +preparedMatrix :: forall n. (KnownNat n) => Dataset n -> IO (Prepared n) +preparedMatrix dataset = do + let matrix = matrixFromRows @n (datasetRows dataset) + _ <- evaluate (checksumMatrix matrix) + pure (Prepared matrix) + +preparedDynamics :: forall n. (KnownNat n) => Dataset n -> IO (PreparedDynamics n) +preparedDynamics dataset = do + Prepared matrix <- preparedMatrix dataset + let initial = vectorFromWeights @n (datasetInitialWeights dataset) + _ <- evaluate (checksumVector initial) + pure (PreparedDynamics matrix initial) + +preparedGraph :: forall n. (KnownNat n) => Dataset n -> IO (Prepared n) +preparedGraph dataset = do + prepared <- preparedMatrix dataset + case finiteStates :: [Finite n] of + [] -> pure prepared + first : _ -> do + _ <- evaluate (Classification.supportEdge (unPrepared prepared) first first) + pure prepared + +preparedWarmClasses :: forall n. (KnownNat n) => Dataset n -> IO (Prepared n) +preparedWarmClasses dataset = do + prepared <- preparedGraph dataset + _ <- evaluate (checksumClasses (Classification.communicatingClasses (unPrepared prepared))) + pure prepared + +preparedWarmIrreducible :: forall n. (KnownNat n) => Dataset n -> IO (Prepared n) +preparedWarmIrreducible dataset = do + prepared <- preparedGraph dataset + _ <- evaluate (Classification.irreducible (unPrepared prepared)) + pure prepared + +preparedWarmPeriod :: forall n. (KnownNat n) => Dataset n -> IO (Prepared n) +preparedWarmPeriod dataset = do + prepared <- preparedGraph dataset + _ <- evaluate (checksumPeriod (Classification.chainPeriod (unPrepared prepared))) + pure prepared + +preparedWarmCyclicClasses :: forall n. (KnownNat n) => Dataset n -> IO (Prepared n) +preparedWarmCyclicClasses dataset = do + prepared <- preparedGraph dataset + _ <- evaluate (checksumCyclicClasses (Classification.cyclicClasses (unPrepared prepared))) + pure prepared + +preparedWarmHittingProbability :: + forall n. + (KnownNat n) => + Dataset n -> + IO (PreparedScalarLookup n) +preparedWarmHittingProbability dataset = do + Prepared matrix <- preparedGraph dataset + let rawLookup = Hitting.eventualProbabilityGivenInitialState matrix (datasetTargets dataset) + lookupValue = eitherOrFail . rawLookup + state = benchmarkState @n + _ <- evaluate (lookupValue state) + pure (PreparedScalarLookup lookupValue state) + +preparedWarmHittingExpectation :: + forall n. + (KnownNat n) => + Dataset n -> + IO (PreparedScalarLookup n) +preparedWarmHittingExpectation dataset = do + Prepared matrix <- preparedGraph dataset + let rawLookup = Hitting.expectationGivenInitialState matrix (datasetTargets dataset) + lookupValue queryState = checksumExpectations [eitherOrFail (rawLookup queryState)] + state = benchmarkState @n + _ <- evaluate (lookupValue state) + pure (PreparedScalarLookup lookupValue state) + +preparedGenerator :: Int -> IO PreparedGen +preparedGenerator seed = + PreparedGen + <$> MWC.initialize + ( U.fromList + [ fromIntegral seed + , fromIntegral (seed * 1664525 + 1013904223) + , 0x9e3779b9 + , 0x243f6a88 + ] + ) + +classesLifecycle :: forall n. (KnownNat n) => Proxy n -> [[Double]] -> Double +classesLifecycle _ = checksumClasses . Classification.communicatingClasses . matrixFromRows @n + +hittingProbabilityChecksum :: + forall n. + (KnownNat n) => + [Finite n] -> + Matrix.TransitionMatrix (Finite n) -> + Double +hittingProbabilityChecksum targets matrix = + weightedEither + [lookupProbability state | state <- finiteStates] + where + lookupProbability = Hitting.eventualProbabilityGivenInitialState matrix targets + +hittingExpectationChecksum :: + forall n. + (KnownNat n) => + [Finite n] -> + Matrix.TransitionMatrix (Finite n) -> + Double +hittingExpectationChecksum targets matrix = + checksumExpectations + (eitherOrFail (sequence [lookupExpectation state | state <- finiteStates])) + where + lookupExpectation = Hitting.expectationGivenInitialState matrix targets + +raceProbabilityChecksum :: + forall n. + (KnownNat n) => + [Finite n] -> + [Finite n] -> + Matrix.TransitionMatrix (Finite n) -> + Double +raceProbabilityChecksum successful competing matrix = + weightedEither + [lookupProbability state | state <- finiteStates] + where + lookupProbability = + Hitting.raceProbabilityGivenInitialState matrix successful competing + +returnExpectationChecksum :: + forall n. + (KnownNat n) => + Matrix.TransitionMatrix (Finite n) -> + Double +returnExpectationChecksum matrix = + checksumExpectations + (eitherOrFail (sequence [lookupExpectation state | state <- finiteStates])) + where + lookupExpectation = Return.expectationGivenInitialState matrix + +absorptionExpectationChecksum :: + forall n. + (KnownNat n) => + Matrix.TransitionMatrix (Finite n) -> + Double +absorptionExpectationChecksum matrix = + checksumExpectations + (eitherOrFail (sequence [lookupExpectation state | state <- finiteStates])) + where + lookupExpectation = Absorption.expectationGivenInitialState matrix + +absorptionProbabilityChecksum :: + forall n. + (KnownNat n) => + Matrix.TransitionMatrix (Finite n) -> + Double +absorptionProbabilityChecksum = + checksumAbsorption . eitherOrFail . Absorption.probabilityMatrix + +benchmarkState :: forall n. (KnownNat n) => Finite n +benchmarkState = + case finiteStates of + [] -> error "benchmark requires a non-empty state space" + first : _ -> first + +benchmarkTarget :: forall n. (KnownNat n) => Dataset n -> Finite n +benchmarkTarget dataset = + case datasetTargets dataset of + [] -> error "benchmark dataset requires at least one target" + target : _ -> target + +checksumPeriod :: Maybe Natural -> Double +checksumPeriod = maybe 0 fromIntegral + +checksumCyclicClasses :: forall n. Maybe [[Finite n]] -> Double +checksumCyclicClasses = maybe 0 (checksumStates . concat) + +weightedEither :: (Show problem) => [Either problem Double] -> Double +weightedEither = + foldl' + (\total value -> total + eitherOrFail value) + 0 + +simulationChecksum :: + forall n. + (KnownNat n) => + Natural -> + Matrix.TransitionMatrix (Finite n) -> + MWC.Gen RealWorld -> + IO Double +simulationChecksum transitions matrix generator = do + case finiteStates :: [Finite n] of + [] -> error "benchmark simulation requires a non-empty state space" + initial : _ -> do + result <- Simulation.simulateMatrix transitions matrix initial generator + pure (checksumStates (eitherOrFail result)) diff --git a/benchmark/haskell/Dataset.hs b/benchmark/haskell/Dataset.hs new file mode 100644 --- /dev/null +++ b/benchmark/haskell/Dataset.hs @@ -0,0 +1,167 @@ +{-# LANGUAGE DeriveAnyClass #-} +{-# LANGUAGE DerivingStrategies #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TypeApplications #-} + +module Dataset ( + Dataset (..), + Entry (..), + Manifest (..), + SomeEntry (..), + datasetAbsorbing, + datasetCompeting, + datasetTargets, + loadDataset, + loadManifest, + selectEntries, + toSomeEntry, +) where + +import Control.DeepSeq (NFData) +import Control.Monad (replicateM, unless) +import Data.Aeson (FromJSON (parseJSON), eitherDecodeFileStrict', withObject, (.:)) +import Data.Binary.Get (Get, getDoublele, isEmpty, runGetOrFail) +import Data.ByteString.Lazy qualified as BL +import Data.Finite (Finite) +import Data.List (sortOn) +import Data.Proxy (Proxy (Proxy)) +import Dtmc.State (finiteStates) +import GHC.Generics (Generic) +import GHC.TypeNats (KnownNat) +import System.FilePath (()) + +data Entry = Entry + { entryId :: String + , entryFamily :: String + , entrySize :: Int + , entrySeed :: Int + , entryFile :: FilePath + , entrySha256 :: String + , entryTargetIndices :: [Int] + , entryAbsorbingIndices :: [Int] + } + deriving stock (Eq, Show, Generic) + deriving anyclass (NFData) + +instance FromJSON Entry where + parseJSON = withObject "benchmark dataset" $ \value -> + Entry + <$> value .: "id" + <*> value .: "family" + <*> value .: "size" + <*> value .: "seed" + <*> value .: "file" + <*> value .: "sha256" + <*> value .: "targets" + <*> value .: "absorbing" + +newtype Manifest = Manifest {manifestEntries :: [Entry]} + deriving stock (Eq, Show) + +instance FromJSON Manifest where + parseJSON = withObject "benchmark manifest" $ \value -> + Manifest <$> value .: "datasets" + +data Dataset n = Dataset + { datasetEntry :: Entry + , datasetRows :: [[Double]] + , datasetInitialWeights :: [Double] + } + deriving stock (Generic) + deriving anyclass (NFData) + +data SomeEntry where + SomeEntry :: (KnownNat n) => Proxy n -> Entry -> SomeEntry + +loadManifest :: FilePath -> IO Manifest +loadManifest path = do + decoded <- eitherDecodeFileStrict' path + case decoded of + Left problem -> fail ("cannot decode benchmark manifest: " ++ problem) + Right manifest -> pure manifest + +selectEntries :: + Maybe String -> + Maybe Int -> + Maybe Int -> + Manifest -> + [Entry] +selectEntries family size seed = + sortOn (\entry -> (entryFamily entry, entrySize entry, entrySeed entry)) + . filter matches + . manifestEntries + where + matches entry = + maybe True (== entryFamily entry) family + && maybe True (== entrySize entry) size + && maybe True (== entrySeed entry) seed + +toSomeEntry :: Entry -> Either String SomeEntry +toSomeEntry entry = + case entrySize entry of + 10 -> Right (SomeEntry (Proxy @10) entry) + 25 -> Right (SomeEntry (Proxy @25) entry) + 50 -> Right (SomeEntry (Proxy @50) entry) + 100 -> Right (SomeEntry (Proxy @100) entry) + 250 -> Right (SomeEntry (Proxy @250) entry) + 500 -> Right (SomeEntry (Proxy @500) entry) + 1000 -> Right (SomeEntry (Proxy @1000) entry) + unsupported -> Left ("unsupported type-level benchmark size: " ++ show unsupported) + +loadDataset :: forall n. FilePath -> Entry -> IO (Dataset n) +loadDataset dataRoot entry = do + let size = entrySize entry + expected = size * size + size + path = dataRoot entryFile entry + bytes <- BL.readFile path + values <- + case runGetOrFail (payload expected) bytes of + Left (_, offset, problem) -> + fail ("cannot decode " ++ path ++ " at byte " ++ show offset ++ ": " ++ problem) + Right (_, _, decoded) -> pure decoded + let (matrixValues, initial) = splitAt (size * size) values + rows = chunksOf size matrixValues + unless (length rows == size && all ((== size) . length) rows) $ + fail ("invalid matrix dimensions in " ++ path) + pure + Dataset + { datasetEntry = entry + , datasetRows = rows + , datasetInitialWeights = initial + } + +datasetTargets :: forall n. (KnownNat n) => Dataset n -> [Finite n] +datasetTargets dataset = statesAtIndices (entryTargetIndices (datasetEntry dataset)) + +datasetAbsorbing :: forall n. (KnownNat n) => Dataset n -> [Finite n] +datasetAbsorbing dataset = statesAtIndices (entryAbsorbingIndices (datasetEntry dataset)) + +datasetCompeting :: forall n. (KnownNat n) => Dataset n -> [Finite n] +datasetCompeting dataset = + take (max 1 (length targets)) [state | state <- finiteStates, state `notElem` targets] + where + targets = datasetTargets dataset + +statesAtIndices :: forall n. (KnownNat n) => [Int] -> [Finite n] +statesAtIndices = map stateAtIndex + where + states = finiteStates :: [Finite n] + stateAtIndex index + | index < 0 || index >= length states = + error ("target index outside state space: " ++ show index) + | otherwise = states !! index + +payload :: Int -> Get [Double] +payload count = do + values <- replicateM count getDoublele + empty <- isEmpty + unless empty (fail "trailing bytes") + pure values + +chunksOf :: Int -> [value] -> [[value]] +chunksOf _ [] = [] +chunksOf width values = + let (prefix, suffix) = splitAt width values + in prefix : chunksOf width suffix diff --git a/benchmark/haskell/Force.hs b/benchmark/haskell/Force.hs new file mode 100644 --- /dev/null +++ b/benchmark/haskell/Force.hs @@ -0,0 +1,77 @@ +{-# LANGUAGE ScopedTypeVariables #-} + +module Force ( + checksumClasses, + checksumAbsorption, + checksumExpectations, + checksumFundamental, + checksumMatrix, + checksumOccupation, + checksumStationary, + checksumStates, + checksumVector, + eitherOrFail, +) where + +import Data.Finite (Finite, getFinite) +import Dtmc.Analysis.Classification (CommClass (..)) +import Dtmc.Analysis.Expectation (Expectation (..)) +import Dtmc.Distribution.Vector qualified as Vector +import Dtmc.State (FiniteState, stateIndex) +import Dtmc.Transition.Matrix qualified as Matrix + +checksumValues :: [Double] -> Double +checksumValues = foldl' (+) 0 + +checksumVector :: Vector.DistributionVector state -> Double +checksumVector = checksumValues . Vector.toList + +checksumMatrix :: Matrix.TransitionMatrix state -> Double +checksumMatrix = checksumValues . concat . Matrix.toRows + +checksumClasses :: (FiniteState state) => [CommClass state] -> Double +checksumClasses classes = + checksumValues + [ fromIntegral (getFinite (stateIndex member)) + | communicatingClass <- classes + , member <- classMembers communicatingClass + ] + +checksumStates :: [Finite n] -> Double +checksumStates = + checksumValues . map (fromIntegral . getFinite) + +checksumExpectations :: [Expectation] -> Double +checksumExpectations = foldl' step 0 + where + step total expectation = + let value = case expectation of + FiniteExpectation finite -> finite + InfiniteExpectation -> 1 + next = total + value + in next + +checksumFundamental :: ([state], [[Double]]) -> Double +checksumFundamental (_, rows) = checksumValues (concat rows) + +checksumAbsorption :: ([state], [state], [[Double]]) -> Double +checksumAbsorption (_, _, rows) = checksumValues (concat rows) + +checksumOccupation :: [[Expectation]] -> Double +checksumOccupation = checksumExpectations . concat + +checksumStationary :: + (FiniteState state) => + [([state], Vector.DistributionVector state)] -> + Double +checksumStationary = foldl' step 0 + where + step total (members, distribution) = + let memberTotal = + checksumValues + (map (fromIntegral . getFinite . stateIndex) members) + next = total + memberTotal + checksumVector distribution + in next + +eitherOrFail :: (Show problem) => Either problem value -> value +eitherOrFail = either (error . ("benchmark operation failed: " ++) . show) id diff --git a/benchmark/haskell/Main.hs b/benchmark/haskell/Main.hs new file mode 100644 --- /dev/null +++ b/benchmark/haskell/Main.hs @@ -0,0 +1,45 @@ +{-# LANGUAGE GADTs #-} + +module Main (main) where + +import Cases (benchmarksFor) +import Control.Monad (when) +import Criterion.Main (defaultMain) +import Criterion.Types (Benchmark) +import Data.Maybe (fromMaybe) +import Dataset +import System.Environment (getArgs, lookupEnv) +import Text.Read (readMaybe) +import Verification (writeVerification) + +main :: IO () +main = do + arguments <- getArgs + dataRoot <- fromMaybe "benchmark/data/generated" <$> lookupEnv "DTMC_BENCH_DATA" + manifest <- loadManifest (dataRoot ++ "/manifest.json") + family <- lookupEnv "DTMC_BENCH_FAMILY" + size <- readEnvironment "DTMC_BENCH_SIZE" + seed <- readEnvironment "DTMC_BENCH_SEED" + let selected = selectEntries family size seed manifest + when (null selected) $ + fail "no datasets matched DTMC_BENCH_FAMILY/DTMC_BENCH_SIZE/DTMC_BENCH_SEED" + typed <- traverse (either fail pure . toSomeEntry) selected + case arguments of + ["--verify-json", outputPath] -> do + maximumSize <- fromMaybe 100 <$> readEnvironment "DTMC_VERIFY_MAX_SIZE" + writeVerification outputPath dataRoot maximumSize typed + _ -> defaultMain (map (benchmarkFor dataRoot) typed) + +benchmarkFor :: FilePath -> SomeEntry -> Benchmark +benchmarkFor dataRoot (SomeEntry proxy entry) = + benchmarksFor proxy dataRoot entry + +readEnvironment :: (Read value) => String -> IO (Maybe value) +readEnvironment name = do + raw <- lookupEnv name + case raw of + Nothing -> pure Nothing + Just value -> + case readMaybe value of + Nothing -> fail ("environment variable " ++ name ++ " is invalid: " ++ value) + Just parsed -> pure (Just parsed) diff --git a/benchmark/haskell/Verification.hs b/benchmark/haskell/Verification.hs new file mode 100644 --- /dev/null +++ b/benchmark/haskell/Verification.hs @@ -0,0 +1,213 @@ +{-# LANGUAGE GADTs #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TypeApplications #-} + +module Verification (writeVerification) where + +import Data.Aeson (Value (Null), encode, object, toJSON, (.=)) +import Data.ByteString.Lazy qualified as BL +import Data.Finite (Finite, getFinite) +import Data.List (transpose) +import Data.Proxy (Proxy) +import Dataset +import Dtmc.Analysis.Absorption qualified as Absorption +import Dtmc.Analysis.Classification qualified as Classification +import Dtmc.Analysis.Event (DiscreteEvent (AtMost, EqualTo, GreaterThan)) +import Dtmc.Analysis.Expectation (Expectation (..)) +import Dtmc.Analysis.FiniteTime qualified as FiniteTime +import Dtmc.Analysis.HittingTime qualified as Hitting +import Dtmc.Analysis.ReturnTime qualified as Return +import Dtmc.Analysis.Stationary qualified as Stationary +import Dtmc.Analysis.VisitCount qualified as VisitCount +import Dtmc.Distribution.Vector qualified as Vector +import Dtmc.Dynamics qualified as Dynamics +import Dtmc.State (finiteStates) +import Dtmc.Transition.Matrix qualified as Matrix +import Force (eitherOrFail) +import GHC.TypeNats (KnownNat) + +writeVerification :: FilePath -> FilePath -> Int -> [SomeEntry] -> IO () +writeVerification outputPath dataRoot maxSize entries = do + results <- traverse (verifySome dataRoot maxSize) entries + BL.writeFile + outputPath + ( encode + ( object + [ "schema_version" .= (1 :: Int) + , "maximum_size" .= maxSize + , "datasets" .= results + ] + ) + ) + +verifySome :: FilePath -> Int -> SomeEntry -> IO Value +verifySome dataRoot maxSize (SomeEntry (_ :: Proxy n) entry) + | entrySize entry > maxSize = + pure + ( object + [ "id" .= entryId entry + , "size" .= entrySize entry + , "skipped" .= True + ] + ) + | otherwise = verifyDataset <$> loadDataset @n dataRoot entry + +verifyDataset :: forall n. (KnownNat n) => Dataset n -> Value +verifyDataset dataset = + object + [ "id" .= entryId entry + , "family" .= family + , "size" .= entrySize entry + , "seed" .= entrySeed entry + , "sha256" .= entrySha256 entry + , "evolve_1" .= Vector.toList (Dynamics.evolveVector initial matrix) + , "evolve_10" .= Vector.toList (Dynamics.evolveVectorN 10 initial matrix) + , "power_10" .= Matrix.toRows (Matrix.power 10 matrix) + , "finite_time_step" .= FiniteTime.stepProbability matrix initialState visitTarget + , "finite_time_n_step_10" .= finiteTimeNStep 10 + , "finite_time_n_step_100" .= finiteTimeNStep 100 + , "finite_time_observation_10" .= finiteTimeObservation 10 + , "finite_time_observation_100" .= finiteTimeObservation 100 + , "classes" .= classes + , "irreducible" .= Classification.irreducible matrix + , "stationary" .= stationary + , "hitting_probability" .= hittingProbabilities + , "hitting_time" .= map expectationValue hittingTimes + , "hitting_bounded_exact_10" .= hittingBounded EqualTo 10 + , "hitting_bounded_exact_100" .= hittingBounded EqualTo 100 + , "hitting_bounded_at_most_10" .= hittingBounded AtMost 10 + , "hitting_bounded_at_most_100" .= hittingBounded AtMost 100 + , "hitting_bounded_greater_than_10" .= hittingBounded GreaterThan 10 + , "hitting_bounded_greater_than_100" .= hittingBounded GreaterThan 100 + , "race_probability" .= raceProbabilities + , "return_mean" .= map expectationValue returnMeans + , "return_bounded_10" .= returnBounded 10 + , "return_bounded_100" .= returnBounded 100 + , "visits_bounded_expectation_10" .= visitsBounded 10 + , "visits_bounded_expectation_100" .= visitsBounded 100 + , "chain_period" .= chainPeriod + , "cyclic_classes" .= cyclicClasses + , "fundamental" .= fundamental + , "absorption_time" .= absorptionTimes + , "absorption_probability" .= absorptionProbabilities + , "occupation" .= occupation + ] + where + entry = datasetEntry dataset + family = entryFamily entry + matrix :: Matrix.TransitionMatrix (Finite n) + matrix = eitherOrFail (Matrix.fromRows (datasetRows dataset)) + initial :: Vector.DistributionVector (Finite n) + initial = eitherOrFail (Vector.fromList (datasetInitialWeights dataset)) + targets = datasetTargets dataset + competing = datasetCompeting dataset + states = finiteStates :: [Finite n] + initialState = + case states of + [] -> error "verification requires a non-empty state space" + first : _ -> first + visitTarget = + case targets of + [] -> error "verification requires at least one target" + target : _ -> target + finiteTimeNStep steps = + FiniteTime.nStepProbability steps matrix initialState visitTarget + finiteTimeObservation time = + FiniteTime.probability + initial + matrix + [FiniteTime.At time visitTarget] + hittingBounded event horizon = + Hitting.probabilityGivenInitialState + (event horizon) + matrix + isTarget + initialState + isTarget state = state `elem` targets + index :: Finite n -> Int + index = fromIntegral . getFinite + classes = + [ map index (Classification.classMembers communicatingClass) + | communicatingClass <- Classification.communicatingClasses matrix + ] + stationary = + [ object + [ "members" .= map index members + , "weights" .= Vector.toList distribution + ] + | (members, distribution) <- + eitherOrFail (Stationary.stationaryDistributions matrix) + ] + hittingProbabilityAt = Hitting.eventualProbabilityGivenInitialState matrix targets + hittingProbabilities = + eitherOrFail (sequence [hittingProbabilityAt state | state <- states]) + hittingTimeAt = Hitting.expectationGivenInitialState matrix targets + hittingTimes = eitherOrFail (sequence [hittingTimeAt state | state <- states]) + raceProbabilities + | family `notElem` ["dense", "low-outdegree"] = Null + | otherwise = + let atState = Hitting.raceProbabilityGivenInitialState matrix targets competing + in toJSON (eitherOrFail (sequence [atState state | state <- states])) + returnMeanAt = Return.expectationGivenInitialState matrix + returnMeans = eitherOrFail (sequence [returnMeanAt state | state <- states]) + returnBounded bound = + Return.probabilityGivenInitialState (AtMost bound) matrix initialState + visitsBounded bound = + VisitCount.boundedExpectationGivenInitialState + bound + initialState + matrix + (== visitTarget) + chainPeriod + | family /= "periodic" = Null + | otherwise = toJSON (Classification.chainPeriod matrix) + cyclicClasses + | family /= "periodic" = Null + | otherwise = + case Classification.cyclicClasses matrix of + Nothing -> Null + Just groups -> toJSON (map (map index) groups) + fundamental + | family /= "absorbing" = Null + | otherwise = + let (transient, values) = eitherOrFail (Absorption.fundamentalMatrix matrix) + in object ["states" .= map index transient, "values" .= values] + absorptionTimes + | family /= "absorbing" = Null + | otherwise = + let atState = Absorption.expectationGivenInitialState matrix + values = eitherOrFail (sequence [atState state | state <- states]) + in toJSONExpectations values + absorptionProbabilities + | family /= "absorbing" = Null + | otherwise = + let (transient, absorbing, rows) = + eitherOrFail (Absorption.probabilityMatrix matrix) + columns + | null rows = replicate (length absorbing) [] + | otherwise = transpose rows + in object + [ "absorbing" .= map index absorbing + , "transient" .= map index transient + , "values" .= columns + ] + occupation + | family `notElem` ["absorbing", "reducible"] = Null + | otherwise = + let values = eitherOrFail (VisitCount.occupationMatrix matrix) + in toJSONExpectationMatrix values + +expectationValue :: Expectation -> Value +expectationValue expectation = + case expectation of + FiniteExpectation value -> object ["finite" .= value] + InfiniteExpectation -> Null + +toJSONExpectations :: [Expectation] -> Value +toJSONExpectations = + toJSON . map expectationValue + +toJSONExpectationMatrix :: [[Expectation]] -> Value +toJSONExpectationMatrix = + toJSON . map (map expectationValue) diff --git a/benchmark/plot.py b/benchmark/plot.py new file mode 100644 --- /dev/null +++ b/benchmark/plot.py @@ -0,0 +1,128 @@ +#!/usr/bin/env python3 +"""Create runtime and speed-ratio plots from aggregated benchmark CSV files.""" + +from __future__ import annotations + +import argparse +import csv +import statistics +from collections import defaultdict +from pathlib import Path + +import matplotlib + +matplotlib.use("Agg") +import matplotlib.pyplot as plt + + +ROOT = Path(__file__).resolve().parent +RESULTS = ROOT / "results" + + +def safe_name(value: str) -> str: + return "".join(character if character.isalnum() else "-" for character in value).strip("-") + + +def plot_runtime(rows: list[dict[str, str]], plots: Path) -> int: + grouped: dict[tuple[str, str, str, int], list[float]] = defaultdict(list) + for row in rows: + grouped[ + (row["family"], row["operation"], row["engine"], int(row["size"])) + ].append(float(row["median_seconds"])) + + combinations = sorted({(family, operation) for family, operation, _, _ in grouped}) + for family, operation in combinations: + fig, axis = plt.subplots(figsize=(7.2, 4.5), constrained_layout=True) + drawn = False + for engine, color in (("dtmc", "#3366cc"), ("pydtmc", "#dc3912")): + points = sorted( + ( + size, + statistics.median(values), + ) + for (candidate_family, candidate_operation, candidate_engine, size), values in grouped.items() + if candidate_family == family + and candidate_operation == operation + and candidate_engine == engine + ) + if points: + axis.plot( + [point[0] for point in points], + [point[1] for point in points], + marker="o", + color=color, + label=engine, + ) + drawn = True + if not drawn: + plt.close(fig) + continue + axis.set_xscale("log") + axis.set_yscale("log") + axis.set_xlabel("states") + axis.set_ylabel("median seconds") + axis.set_title(f"{family}: {operation}") + axis.grid(True, which="both", alpha=0.25) + axis.legend() + fig.savefig(plots / f"{safe_name(family)}--{safe_name(operation)}.svg") + plt.close(fig) + return len(combinations) + + +def plot_ratios(rows: list[dict[str, str]], plots: Path) -> int: + grouped: dict[tuple[str, str], list[dict[str, str]]] = defaultdict(list) + for row in rows: + grouped[(row["family"], row["operation"])].append(row) + + for (family, operation), group in sorted(grouped.items()): + ordered = sorted(group, key=lambda row: int(row["size"])) + sizes = [int(row["size"]) for row in ordered] + ratios = [float(row["geometric_median_pydtmc_over_dtmc"]) for row in ordered] + lows = [float(row["ci95_low"]) for row in ordered] + highs = [float(row["ci95_high"]) for row in ordered] + + fig, axis = plt.subplots(figsize=(7.2, 4.5), constrained_layout=True) + axis.plot(sizes, ratios, marker="o", color="#6a3d9a", label="PyDTMC / dtmc") + axis.fill_between(sizes, lows, highs, color="#6a3d9a", alpha=0.18, label="95% CI") + axis.axhline(1.0, color="#555555", linestyle="--", linewidth=1.0) + axis.set_xscale("log") + axis.set_yscale("log") + axis.set_xlabel("states") + axis.set_ylabel("median speed ratio") + axis.set_title(f"{family}: {operation} speed ratio") + axis.grid(True, which="both", alpha=0.25) + axis.legend() + fig.savefig( + plots / f"{safe_name(family)}--{safe_name(operation)}--speed-ratio.svg" + ) + plt.close(fig) + return len(grouped) + + +def read_csv(path: Path) -> list[dict[str, str]]: + with path.open(newline="", encoding="utf-8") as stream: + return list(csv.DictReader(stream)) + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--results-root", type=Path, default=RESULTS) + args = parser.parse_args() + results = args.results_root.resolve() + + summary_path = results / "summary.csv" + ratio_path = results / "ratio-summary.csv" + if not summary_path.exists() or not ratio_path.exists(): + raise SystemExit("run benchmark/analyse.py before plotting") + + plots = results / "plots" + plots.mkdir(parents=True, exist_ok=True) + for stale in plots.glob("*.svg"): + stale.unlink() + runtime_count = plot_runtime(read_csv(summary_path), plots) + ratio_count = plot_ratios(read_csv(ratio_path), plots) + print(f"wrote {runtime_count} runtime and {ratio_count} ratio plots to {plots}") + + +if __name__ == "__main__": + main() diff --git a/benchmark/python/bench.py b/benchmark/python/bench.py new file mode 100644 --- /dev/null +++ b/benchmark/python/bench.py @@ -0,0 +1,585 @@ +#!/usr/bin/env python3 +"""Pyperf benchmarks matching the public dtmc benchmark operations.""" + +from __future__ import annotations + +import hashlib +import json +import os +from dataclasses import dataclass +from pathlib import Path +from time import perf_counter +from typing import Any, Callable + +import numpy as np +import pyperf +from pydtmc import MarkovChain + + +@dataclass(frozen=True) +class Dataset: + metadata: dict[str, Any] + matrix: np.ndarray + initial: np.ndarray + + @property + def name(self) -> str: + return str(self.metadata["id"]) + + @property + def family(self) -> str: + return str(self.metadata["family"]) + + @property + def size(self) -> int: + return int(self.metadata["size"]) + + @property + def seed(self) -> int: + return int(self.metadata["seed"]) + + @property + def targets(self) -> list[int]: + return [int(value) for value in self.metadata["targets"]] + + @property + def absorbing(self) -> list[int]: + return [int(value) for value in self.metadata["absorbing"]] + + @property + def competing(self) -> list[int]: + targets = set(self.targets) + return [state for state in range(self.size) if state not in targets][ + : max(1, len(targets)) + ] + + +def data_root() -> Path: + return Path(os.environ.get("DTMC_BENCH_DATA", "benchmark/data/generated")).resolve() + + +def load_selected_dataset() -> Dataset: + root = data_root() + manifest = json.loads((root / "manifest.json").read_text(encoding="utf-8")) + family = os.environ.get("DTMC_BENCH_FAMILY") + size = os.environ.get("DTMC_BENCH_SIZE") + seed = os.environ.get("DTMC_BENCH_SEED") + matches = [ + entry + for entry in manifest["datasets"] + if (family is None or entry["family"] == family) + and (size is None or entry["size"] == int(size)) + and (seed is None or entry["seed"] == int(seed)) + ] + if len(matches) != 1: + raise RuntimeError( + "select exactly one dataset with DTMC_BENCH_FAMILY, " + "DTMC_BENCH_SIZE, and DTMC_BENCH_SEED" + ) + entry = matches[0] + payload_path = root / entry["file"] + digest = hashlib.sha256(payload_path.read_bytes()).hexdigest() + if digest != entry["sha256"]: + raise RuntimeError(f"SHA-256 mismatch for {payload_path}") + n = int(entry["size"]) + values = np.fromfile(payload_path, dtype=" float: + array = np.asarray(value, dtype=np.float64).ravel(order="C") + return float(np.sum(array, dtype=np.float64)) + + +def consume_chain(chain: MarkovChain) -> float: + return checksum_array(chain.p) + + +def consume_classes(classes: list[list[str]]) -> int: + return sum(int(state) - 1 for group in classes for state in group) + + +def consume_classes_access(classes: list[list[str]]) -> bool: + return classes is not None + + +def consume_bool(value: bool) -> int: + return int(value) + + +def consume_float(value: float) -> float: + return float(value) + + +def consume_sequence(value: list[int]) -> int: + return sum(map(int, value)) + + +def consume_optional_array(value: Any) -> float: + if value is None: + raise RuntimeError("PyDTMC operation unexpectedly returned None") + return checksum_array(value) + + +def occupation_including_initial(chain: MarkovChain) -> np.ndarray: + """Adapt PyDTMC's positive-time visit counts to dtmc's time-zero convention.""" + values = chain.mean_number_visits() + if values is None: + raise RuntimeError("PyDTMC operation unexpectedly returned None") + adjusted = np.asarray(values, dtype=np.float64).copy() + adjusted.flat[:: adjusted.shape[0] + 1] += 1.0 + return adjusted + + +def bounded_return_probability(chain: MarkovChain, steps: int) -> float: + probabilities = chain.first_passage_probabilities(steps, 0, [0]) + return float(np.sum(probabilities, dtype=np.float64)) + + +def finite_time_probability( + chain: MarkovChain, + steps: int, + initial: np.ndarray, + destination: int, +) -> float: + distribution = chain.redistribute( + steps, + initial_status=initial, + output_last=True, + ) + return float(distribution[destination]) + + +def bounded_hitting_masses( + chain: MarkovChain, + steps: int, + initial_state: int, + targets: list[int], +) -> np.ndarray: + return np.asarray( + chain.first_passage_probabilities(steps, initial_state, targets), + dtype=np.float64, + ) + + +def target_absorbing_matrix( + matrix: np.ndarray, + targets: list[int], +) -> np.ndarray: + """Preserve first hits while making PyDTMC's target events disjoint.""" + adjusted = matrix.copy() + adjusted[targets, :] = 0.0 + adjusted[targets, targets] = 1.0 + adjusted.flags.writeable = False + return adjusted + + +def exact_hitting_probability( + chain: MarkovChain, + steps: int, + initial_state: int, + targets: list[int], +) -> float: + masses = bounded_hitting_masses(chain, steps, initial_state, targets) + return float(masses[-1]) + + +def bounded_hitting_probability( + chain: MarkovChain, + steps: int, + initial_state: int, + targets: list[int], +) -> float: + masses = bounded_hitting_masses(chain, steps, initial_state, targets) + return float(np.sum(masses, dtype=np.float64)) + + +def upper_hitting_probability( + chain: MarkovChain, + steps: int, + initial_state: int, + targets: list[int], +) -> float: + return 1.0 - bounded_hitting_probability( + chain, + steps, + initial_state, + targets, + ) + + +def bounded_visit_expectation( + chain: MarkovChain, steps: int, rewards: np.ndarray +) -> float: + return float(chain.expected_rewards(steps - 1, rewards)[0]) + + +def fresh_chain(dataset: Dataset) -> MarkovChain: + return MarkovChain(dataset.matrix) + + +def operation_selected(name: str) -> bool: + selected_many = os.environ.get("DTMC_BENCH_OPERATIONS") + if selected_many is not None: + operations = [item for item in selected_many.split(",") if item] + return any(name.endswith(f"/{operation}") for operation in operations) + + selected = os.environ.get("DTMC_BENCH_OPERATION") + return selected is None or selected in name + + +def register_fresh( + runner: pyperf.Runner, + name: str, + setup: Callable[[], Any], + operation: Callable[[Any], Any], + consume: Callable[[Any], Any], +) -> None: + """Exclude fixture setup while still using a fresh cache for every sample.""" + if not operation_selected(name): + return + + def timed(loops: int) -> float: + elapsed = 0.0 + for _ in range(loops): + fixture = setup() + started = perf_counter() + result = operation(fixture) + consume(result) + elapsed += perf_counter() - started + return elapsed + + runner.bench_time_func(name, timed) + + +def register_warm( + runner: pyperf.Runner, + name: str, + fixture: Any, + operation: Callable[[Any], Any], + consume: Callable[[Any], Any], +) -> None: + if not operation_selected(name): + return + inner_loops = 10_000 + + def timed(loops: int) -> float: + started = perf_counter() + for _ in range(loops * inner_loops): + consume(operation(fixture)) + return perf_counter() - started + + runner.bench_time_func(name, timed, inner_loops=inner_loops) + + +def register_benchmarks(runner: pyperf.Runner, dataset: Dataset) -> None: + prefix = dataset.name + matrix = dataset.matrix + initial = dataset.initial + targets = dataset.targets + competing = dataset.competing + target = targets[0] + hitting_matrix = target_absorbing_matrix(matrix, targets) + point_initial = np.zeros(dataset.size, dtype=np.float64) + point_initial[0] = 1.0 + point_initial.flags.writeable = False + + register_fresh( + runner, + f"{prefix}/construction/public-consumed", + lambda: matrix, + MarkovChain, + consume_chain, + ) + + for steps in (1, 10, 100): + label = "one-step" if steps == 1 else f"k-{steps}" + register_fresh( + runner, + f"{prefix}/evolution/{label}", + lambda: fresh_chain(dataset), + lambda chain, count=steps: chain.redistribute( + count, initial_status=initial, output_last=True + ), + checksum_array, + ) + + if dataset.size <= 100: + register_fresh( + runner, + f"{prefix}/finite-time/step", + lambda: fresh_chain(dataset), + lambda chain: chain.p[0, target], + consume_float, + ) + for steps in (10, 100): + register_fresh( + runner, + f"{prefix}/finite-time/n-step/k-{steps}", + lambda: fresh_chain(dataset), + lambda chain, count=steps: finite_time_probability( + chain, + count, + point_initial, + target, + ), + consume_float, + ) + register_fresh( + runner, + f"{prefix}/finite-time/observation/k-{steps}", + lambda: fresh_chain(dataset), + lambda chain, count=steps: finite_time_probability( + chain, + count, + initial, + target, + ), + consume_float, + ) + + if dataset.size <= 500: + for exponent in (2, 10, 100): + register_fresh( + runner, + f"{prefix}/power/{exponent}", + lambda: fresh_chain(dataset), + lambda chain, value=exponent: chain.to_nth_order(value), + consume_chain, + ) + + if dataset.family != "dense" or dataset.size <= 500: + register_fresh( + runner, + f"{prefix}/structure/classes-lifecycle", + lambda: matrix, + lambda value: MarkovChain(value).communicating_classes, + consume_classes, + ) + register_fresh( + runner, + f"{prefix}/structure/classes-cold", + lambda: fresh_chain(dataset), + lambda chain: chain.communicating_classes, + consume_classes, + ) + + warm_classes = fresh_chain(dataset) + consume_classes(warm_classes.communicating_classes) + register_warm( + runner, + f"{prefix}/structure/classes-warm/access", + warm_classes, + lambda chain: chain.communicating_classes, + consume_classes_access, + ) + register_warm( + runner, + f"{prefix}/structure/classes-warm/consumed", + warm_classes, + lambda chain: chain.communicating_classes, + consume_classes, + ) + register_fresh( + runner, + f"{prefix}/structure/irreducible-cold", + lambda: fresh_chain(dataset), + lambda chain: chain.is_irreducible, + consume_bool, + ) + + if dataset.family == "periodic": + register_fresh( + runner, + f"{prefix}/structure/period-cold", + lambda: fresh_chain(dataset), + lambda chain: chain.period, + consume_float, + ) + warm_period = fresh_chain(dataset) + consume_float(warm_period.period) + register_warm( + runner, + f"{prefix}/structure/period-warm", + warm_period, + lambda chain: chain.period, + consume_float, + ) + register_fresh( + runner, + f"{prefix}/structure/cyclic-classes-cold", + lambda: fresh_chain(dataset), + lambda chain: chain.cyclic_classes, + consume_classes, + ) + warm_cyclic_classes = fresh_chain(dataset) + consume_classes(warm_cyclic_classes.cyclic_classes) + register_warm( + runner, + f"{prefix}/structure/cyclic-classes-warm", + warm_cyclic_classes, + lambda chain: chain.cyclic_classes, + consume_classes, + ) + + warm_irreducible = fresh_chain(dataset) + consume_bool(warm_irreducible.is_irreducible) + register_warm( + runner, + f"{prefix}/structure/irreducible-warm", + warm_irreducible, + lambda chain: chain.is_irreducible, + consume_bool, + ) + + if dataset.size <= 500: + register_fresh( + runner, + f"{prefix}/stationary", + lambda: fresh_chain(dataset), + lambda chain: chain.pi, + checksum_array, + ) + register_fresh( + runner, + f"{prefix}/hitting-probability/cold-all-states", + lambda: fresh_chain(dataset), + lambda chain: chain.hitting_probabilities(targets), + checksum_array, + ) + register_fresh( + runner, + f"{prefix}/hitting-time/cold-all-states", + lambda: fresh_chain(dataset), + lambda chain: chain.hitting_times(targets), + checksum_array, + ) + + if dataset.family in {"dense", "low-outdegree"}: + register_fresh( + runner, + f"{prefix}/race/forward-committor", + lambda: fresh_chain(dataset), + lambda chain: chain.committor_probabilities( + "forward", competing, targets + ), + consume_optional_array, + ) + + if dataset.family in {"dense", "low-outdegree"} and dataset.size <= 500: + register_fresh( + runner, + f"{prefix}/return/mean-recurrence", + lambda: fresh_chain(dataset), + lambda chain: chain.mean_recurrence_times(), + consume_optional_array, + ) + + if dataset.size <= 100: + rewards = np.zeros(dataset.size, dtype=np.float64) + rewards[targets[0]] = 1.0 + rewards.flags.writeable = False + for steps in (10, 100): + for label, operation in ( + ("exact", exact_hitting_probability), + ("at-most", bounded_hitting_probability), + ("greater-than", upper_hitting_probability), + ): + register_fresh( + runner, + f"{prefix}/hitting/bounded/{label}/k-{steps}", + lambda: MarkovChain(hitting_matrix), + lambda chain, count=steps, query=operation: query( + chain, + count, + 0, + targets, + ), + consume_float, + ) + register_fresh( + runner, + f"{prefix}/return/bounded/k-{steps}", + lambda: fresh_chain(dataset), + lambda chain, count=steps: bounded_return_probability(chain, count), + consume_float, + ) + register_fresh( + runner, + f"{prefix}/visits/bounded-expectation/k-{steps}", + lambda: fresh_chain(dataset), + lambda chain, count=steps: bounded_visit_expectation( + chain, count, rewards + ), + consume_float, + ) + + if dataset.family == "absorbing" and dataset.size <= 500: + register_fresh( + runner, + f"{prefix}/fundamental-matrix", + lambda: fresh_chain(dataset), + lambda chain: chain.fundamental_matrix, + consume_optional_array, + ) + register_fresh( + runner, + f"{prefix}/absorption/probabilities", + lambda: fresh_chain(dataset), + lambda chain: chain.absorption_probabilities(), + consume_optional_array, + ) + register_fresh( + runner, + f"{prefix}/absorption-time", + lambda: fresh_chain(dataset), + lambda chain: chain.mean_absorption_times(), + consume_optional_array, + ) + + if dataset.family in {"absorbing", "reducible"} and dataset.size <= 250: + register_fresh( + runner, + f"{prefix}/occupation-matrix", + lambda: fresh_chain(dataset), + occupation_including_initial, + consume_optional_array, + ) + + if dataset.family in {"dense", "low-outdegree"}: + for transitions in (10_000, 100_000): + register_fresh( + runner, + f"{prefix}/simulation/{transitions}", + lambda: fresh_chain(dataset), + lambda chain, count=transitions: chain.simulate( + count, + initial_state=0, + output_indices=True, + seed=dataset.seed, + ), + consume_sequence, + ) + + +def main() -> None: + dataset = load_selected_dataset() + # One cold operation per value prevents pyperf calibration from recreating + # an expensive untimed fixture thousands of times. Three processes with ten + # values give 30 independent full-operation samples in the normal suite. + runner = pyperf.Runner(processes=3, values=10, warmups=3, loops=1) + runner.metadata["dataset"] = dataset.name + runner.metadata["dataset_sha256"] = dataset.metadata["sha256"] + runner.metadata["pydtmc_version"] = "9.0.0" + register_benchmarks(runner, dataset) + + +if __name__ == "__main__": + main() diff --git a/benchmark/python/pyproject.toml b/benchmark/python/pyproject.toml new file mode 100644 --- /dev/null +++ b/benchmark/python/pyproject.toml @@ -0,0 +1,15 @@ +[project] +name = "dtmc-pydtmc-benchmark" +version = "0.1.0" +requires-python = ">=3.12,<3.13" +dependencies = [ + "matplotlib==3.10.6", + "networkx==3.5", + "numpy==2.3.1", + "pyperf==2.9.0", + "PyDTMC==9.0.0", + "scipy==1.16.1", +] + +[tool.dtmc-benchmark] +pydtmc-sdist-sha256 = "e3cbe0e192bf85e1941b0b8b85314a5ae273df04aaa7c168667d0bb4fee5c8ef" diff --git a/benchmark/python/requirements.lock b/benchmark/python/requirements.lock new file mode 100644 --- /dev/null +++ b/benchmark/python/requirements.lock @@ -0,0 +1,18 @@ +# Exact Python 3.12 environment resolved on 2026-09-08. PyDTMC's +# source-distribution hash is recorded in pyproject.toml. +contourpy==1.3.3 +cycler==0.12.1 +fonttools==4.64.0 +kiwisolver==1.5.1 +matplotlib==3.10.6 +networkx==3.5 +numpy==2.3.1 +packaging==26.3 +pillow==12.3.0 +psutil==7.2.2 +PyDTMC==9.0.0 +pyparsing==3.3.2 +pyperf==2.9.0 +python-dateutil==2.9.0.post0 +scipy==1.16.1 +six==1.17.0 diff --git a/benchmark/python/verify.py b/benchmark/python/verify.py new file mode 100644 --- /dev/null +++ b/benchmark/python/verify.py @@ -0,0 +1,463 @@ +#!/usr/bin/env python3 +"""Compare untimed dtmc outputs with PyDTMC on the shared fixtures.""" + +from __future__ import annotations + +import argparse +import json +import math +from dataclasses import dataclass, asdict +from pathlib import Path +from typing import Any + +import numpy as np +from pydtmc import MarkovChain + +from bench import ( + Dataset, + bounded_hitting_probability, + bounded_return_probability, + bounded_visit_expectation, + data_root, + exact_hitting_probability, + finite_time_probability, + occupation_including_initial, + target_absorbing_matrix, + upper_hitting_probability, +) + + +@dataclass +class Comparison: + dataset: str + operation: str + max_absolute_error: float + max_relative_error: float + passed: bool + + +def load_dataset(root: Path, entry: dict[str, Any]) -> Dataset: + n = int(entry["size"]) + values = np.fromfile(root / entry["file"], dtype=" np.ndarray: + def decode(item: Any) -> float: + if item is None: + return math.inf + if isinstance(item, dict) and "finite" in item: + return float(item["finite"]) + if isinstance(item, list): + raise TypeError("nested expectation list reached scalar decoder") + return float(item) + + if isinstance(value, list) and value and isinstance(value[0], list): + return np.asarray([[decode(item) for item in row] for row in value], dtype=float) + return np.asarray([decode(item) for item in value], dtype=float) + + +def compare_numeric( + dataset: str, + operation: str, + haskell: Any, + python: Any, + atol: float, + rtol: float, +) -> Comparison: + left = np.asarray(haskell, dtype=float) + right = np.asarray(python, dtype=float) + if left.shape != right.shape: + raise AssertionError( + f"{dataset}/{operation}: shape mismatch {left.shape} != {right.shape}" + ) + if not np.array_equal(np.isinf(left), np.isinf(right)): + raise AssertionError(f"{dataset}/{operation}: infinity masks differ") + finite = np.isfinite(left) & np.isfinite(right) + if not np.array_equal(np.isnan(left), np.isnan(right)): + raise AssertionError(f"{dataset}/{operation}: NaN masks differ") + if np.any(finite): + absolute = np.abs(left[finite] - right[finite]) + scale = np.maximum(np.maximum(np.abs(left[finite]), np.abs(right[finite])), 1e-300) + relative = absolute / scale + max_absolute = float(np.max(absolute)) + max_relative = float(np.max(relative)) + passed = bool(np.all(absolute <= atol + rtol * np.abs(right[finite]))) + else: + max_absolute = 0.0 + max_relative = 0.0 + passed = True + return Comparison(dataset, operation, max_absolute, max_relative, passed) + + +def state_index(label: str) -> int: + # Default PyDTMC labels are one-based decimal strings. + return int(label) - 1 + + +def normalized_partition(groups: list[list[int]]) -> list[list[int]]: + return sorted(sorted(group) for group in groups) + + +def compare_dataset( + record: dict[str, Any], + dataset: Dataset, + atol: float, + rtol: float, +) -> list[Comparison]: + name = dataset.name + chain = MarkovChain(dataset.matrix) + targets = dataset.targets + hitting_chain = MarkovChain(target_absorbing_matrix(dataset.matrix, targets)) + rewards = np.zeros(dataset.size, dtype=np.float64) + rewards[targets[0]] = 1.0 + point_initial = np.zeros(dataset.size, dtype=np.float64) + point_initial[0] = 1.0 + comparisons = [ + compare_numeric( + name, + "evolve_1", + record["evolve_1"], + chain.redistribute(1, initial_status=dataset.initial, output_last=True), + atol, + rtol, + ), + compare_numeric( + name, + "evolve_10", + record["evolve_10"], + chain.redistribute(10, initial_status=dataset.initial, output_last=True), + atol, + rtol, + ), + compare_numeric( + name, + "power_10", + record["power_10"], + chain.to_nth_order(10).p, + atol, + rtol, + ), + compare_numeric( + name, + "finite_time_step", + [record["finite_time_step"]], + [chain.p[0, targets[0]]], + atol, + rtol, + ), + compare_numeric( + name, + "finite_time_n_step_10", + [record["finite_time_n_step_10"]], + [finite_time_probability(chain, 10, point_initial, targets[0])], + atol, + rtol, + ), + compare_numeric( + name, + "finite_time_n_step_100", + [record["finite_time_n_step_100"]], + [finite_time_probability(chain, 100, point_initial, targets[0])], + atol, + rtol, + ), + compare_numeric( + name, + "finite_time_observation_10", + [record["finite_time_observation_10"]], + [finite_time_probability(chain, 10, dataset.initial, targets[0])], + atol, + rtol, + ), + compare_numeric( + name, + "finite_time_observation_100", + [record["finite_time_observation_100"]], + [finite_time_probability(chain, 100, dataset.initial, targets[0])], + atol, + rtol, + ), + compare_numeric( + name, + "hitting_probability", + record["hitting_probability"], + chain.hitting_probabilities(targets), + atol, + rtol, + ), + compare_numeric( + name, + "hitting_time", + expectation_array(record["hitting_time"]), + chain.hitting_times(targets), + atol, + rtol, + ), + compare_numeric( + name, + "hitting_bounded_exact_10", + [record["hitting_bounded_exact_10"]], + [exact_hitting_probability(hitting_chain, 10, 0, targets)], + atol, + rtol, + ), + compare_numeric( + name, + "hitting_bounded_exact_100", + [record["hitting_bounded_exact_100"]], + [exact_hitting_probability(hitting_chain, 100, 0, targets)], + atol, + rtol, + ), + compare_numeric( + name, + "hitting_bounded_at_most_10", + [record["hitting_bounded_at_most_10"]], + [bounded_hitting_probability(hitting_chain, 10, 0, targets)], + atol, + rtol, + ), + compare_numeric( + name, + "hitting_bounded_at_most_100", + [record["hitting_bounded_at_most_100"]], + [bounded_hitting_probability(hitting_chain, 100, 0, targets)], + atol, + rtol, + ), + compare_numeric( + name, + "hitting_bounded_greater_than_10", + [record["hitting_bounded_greater_than_10"]], + [upper_hitting_probability(hitting_chain, 10, 0, targets)], + atol, + rtol, + ), + compare_numeric( + name, + "hitting_bounded_greater_than_100", + [record["hitting_bounded_greater_than_100"]], + [upper_hitting_probability(hitting_chain, 100, 0, targets)], + atol, + rtol, + ), + compare_numeric( + name, + "return_bounded_10", + [record["return_bounded_10"]], + [bounded_return_probability(chain, 10)], + atol, + rtol, + ), + compare_numeric( + name, + "return_bounded_100", + [record["return_bounded_100"]], + [bounded_return_probability(chain, 100)], + atol, + rtol, + ), + compare_numeric( + name, + "visits_bounded_expectation_10", + [record["visits_bounded_expectation_10"]], + [bounded_visit_expectation(chain, 10, rewards)], + atol, + rtol, + ), + compare_numeric( + name, + "visits_bounded_expectation_100", + [record["visits_bounded_expectation_100"]], + [bounded_visit_expectation(chain, 100, rewards)], + atol, + rtol, + ), + ] + + if dataset.family in {"dense", "low-outdegree"}: + py_race = chain.committor_probabilities( + "forward", dataset.competing, targets + ) + if py_race is None: + raise AssertionError(f"{name}: PyDTMC returned no committor probabilities") + comparisons.append( + compare_numeric( + name, + "race_probability", + record["race_probability"], + py_race, + atol, + rtol, + ) + ) + py_return_mean = chain.mean_recurrence_times() + if py_return_mean is None: + raise AssertionError(f"{name}: PyDTMC returned no mean recurrence times") + comparisons.append( + compare_numeric( + name, + "return_mean", + expectation_array(record["return_mean"]), + py_return_mean, + atol, + rtol, + ) + ) + + haskell_classes = sorted(sorted(group) for group in record["classes"]) + python_classes = sorted(sorted(state_index(state) for state in group) for group in chain.communicating_classes) + if haskell_classes != python_classes: + raise AssertionError(f"{name}: communicating classes differ") + if bool(record["irreducible"]) != bool(chain.is_irreducible): + raise AssertionError(f"{name}: irreducibility differs") + + if dataset.family == "periodic": + if int(record["chain_period"]) != int(chain.period): + raise AssertionError(f"{name}: chain periods differ") + haskell_cyclic = normalized_partition(record["cyclic_classes"]) + python_cyclic = normalized_partition( + [[state_index(state) for state in group] for group in chain.cyclic_classes] + ) + if haskell_cyclic != python_cyclic: + raise AssertionError(f"{name}: cyclic classes differ") + + haskell_stationary = { + tuple(item["members"]): np.asarray(item["weights"], dtype=float) + for item in record["stationary"] + } + python_stationary: dict[tuple[int, ...], np.ndarray] = {} + for vector in chain.pi: + array = np.asarray(vector, dtype=float) + support = tuple(int(i) for i in np.flatnonzero(array > 0.0)) + python_stationary[support] = array + if set(haskell_stationary) != set(python_stationary): + raise AssertionError(f"{name}: stationary supports differ") + for support, haskell_vector in haskell_stationary.items(): + comparisons.append( + compare_numeric( + name, + f"stationary[{','.join(map(str, support))}]", + haskell_vector, + python_stationary[support], + atol, + rtol, + ) + ) + + if dataset.family == "absorbing": + fundamental = record["fundamental"] + py_fundamental = chain.fundamental_matrix + if py_fundamental is None: + raise AssertionError(f"{name}: PyDTMC did not classify fixture as absorbing") + comparisons.append( + compare_numeric( + name, + "fundamental", + fundamental["values"], + py_fundamental, + atol, + rtol, + ) + ) + absorption_probability = record["absorption_probability"] + py_absorbing = [state_index(state) for state in chain.absorbing_states] + py_transient = [state_index(state) for state in chain.transient_states] + if absorption_probability["absorbing"] != py_absorbing: + raise AssertionError(f"{name}: absorbing-state order differs") + if absorption_probability["transient"] != py_transient: + raise AssertionError(f"{name}: transient-state order differs") + py_absorption_probability = chain.absorption_probabilities() + if py_absorption_probability is None: + raise AssertionError(f"{name}: PyDTMC returned no absorption probabilities") + comparisons.append( + compare_numeric( + name, + "absorption_probability", + absorption_probability["values"], + py_absorption_probability, + atol, + rtol, + ) + ) + transient = [int(index) for index in fundamental["states"]] + py_absorption = chain.mean_absorption_times() + if py_absorption is None: + raise AssertionError(f"{name}: PyDTMC returned no absorption times") + hs_absorption = expectation_array(record["absorption_time"])[transient] + comparisons.append( + compare_numeric( + name, + "absorption_time", + hs_absorption, + py_absorption, + atol, + rtol, + ) + ) + + if dataset.family in {"absorbing", "reducible"}: + py_occupation = occupation_including_initial(chain) + comparisons.append( + compare_numeric( + name, + "occupation", + expectation_array(record["occupation"]), + py_occupation, + atol, + rtol, + ) + ) + + return comparisons + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("haskell_json", type=Path) + parser.add_argument("--output", type=Path, required=True) + parser.add_argument("--atol", type=float, default=1e-10) + parser.add_argument("--rtol", type=float, default=1e-8) + args = parser.parse_args() + + root = data_root() + manifest = json.loads((root / "manifest.json").read_text(encoding="utf-8")) + entries = {entry["id"]: entry for entry in manifest["datasets"]} + haskell = json.loads(args.haskell_json.read_text(encoding="utf-8")) + comparisons: list[Comparison] = [] + skipped: list[str] = [] + for record in haskell["datasets"]: + if record.get("skipped"): + skipped.append(record["id"]) + continue + entry = entries[record["id"]] + comparisons.extend( + compare_dataset(record, load_dataset(root, entry), args.atol, args.rtol) + ) + + failed = [comparison for comparison in comparisons if not comparison.passed] + output = { + "schema_version": 1, + "absolute_tolerance": args.atol, + "relative_tolerance": args.rtol, + "comparisons": [asdict(comparison) for comparison in comparisons], + "skipped": skipped, + "passed": not failed, + } + args.output.parent.mkdir(parents=True, exist_ok=True) + args.output.write_text(json.dumps(output, indent=2) + "\n", encoding="utf-8") + if failed: + names = ", ".join(f"{item.dataset}/{item.operation}" for item in failed) + raise SystemExit(f"numerical verification failed: {names}") + print(f"verified {len(comparisons)} operation results; maximum size {haskell['maximum_size']}") + + +if __name__ == "__main__": + main() diff --git a/benchmark/results/environment.json b/benchmark/results/environment.json new file mode 100644 --- /dev/null +++ b/benchmark/results/environment.json @@ -0,0 +1,36 @@ +{ + "captured_at_utc": "2026-09-14T09:16:40Z", + "platform": "macOS-15.6.1-arm64-arm-64bit", + "machine": "arm64", + "processor": "arm", + "cpu_brand": "Apple M1", + "python": "Python 3.13.9", + "python_packages": "contourpy==1.3.3\ncycler==0.12.1\nfonttools==4.64.0\nkiwisolver==1.5.1\nmatplotlib==3.10.6\nnetworkx==3.5\nnumpy==2.3.1\npackaging==26.3\npillow==12.3.0\npsutil==7.2.2\nPyDTMC==9.0.0\npyparsing==3.3.2\npyperf==2.9.0\npython-dateutil==2.9.0.post0\nscipy==1.16.1\nsix==1.17.0", + "numpy_configuration": "/Users/a123/CodingProjects/dtmc/benchmark/.venv/lib/python3.13/site-packages/numpy/__config__.py:155: UserWarning: Install `pyyaml` for better output\n warnings.warn(\"Install `pyyaml` for better output\", stacklevel=1)\n{\n \"Compilers\": {\n \"c\": {\n \"name\": \"clang\",\n \"linker\": \"ld64\",\n \"version\": \"15.0.0\",\n \"commands\": \"cc\"\n },\n \"cython\": {\n \"name\": \"cython\",\n \"linker\": \"cython\",\n \"version\": \"3.1.2\",\n \"commands\": \"cython\"\n },\n \"c++\": {\n \"name\": \"clang\",\n \"linker\": \"ld64\",\n \"version\": \"15.0.0\",\n \"commands\": \"c++\"\n }\n },\n \"Machine Information\": {\n \"host\": {\n \"cpu\": \"aarch64\",\n \"family\": \"aarch64\",\n \"endian\": \"little\",\n \"system\": \"darwin\"\n },\n \"build\": {\n \"cpu\": \"aarch64\",\n \"family\": \"aarch64\",\n \"endian\": \"little\",\n \"system\": \"darwin\"\n }\n },\n \"Build Dependencies\": {\n \"blas\": {\n \"name\": \"accelerate\",\n \"found\": true,\n \"version\": \"unknown\",\n \"detection method\": \"system\",\n \"include directory\": \"unknown\",\n \"lib directory\": \"unknown\",\n \"openblas configuration\": \"unknown\",\n \"pc file directory\": \"unknown\"\n },\n \"lapack\": {\n \"name\": \"accelerate\",\n \"found\": true,\n \"version\": \"unknown\",\n \"detection method\": \"system\",\n \"include directory\": \"unknown\",\n \"lib directory\": \"unknown\",\n \"openblas configuration\": \"unknown\",\n \"pc file directory\": \"unknown\"\n }\n },\n \"Python Information\": {\n \"path\": \"/private/var/folders/y6/nj790rtn62lfktb1sh__79hc0000gn/T/build-env-oawxqquo/bin/python\",\n \"version\": \"3.13\"\n },\n \"SIMD Extensions\": {\n \"baseline\": [\n \"NEON\",\n \"NEON_FP16\",\n \"NEON_VFPV4\",\n \"ASIMD\"\n ],\n \"found\": [\n \"ASIMDHP\"\n ],\n \"not found\": [\n \"ASIMDFHM\"\n ]\n }\n}", + "ghc": "The Glorious Glasgow Haskell Compilation System, version 9.10.3", + "cabal": "cabal-install version 3.16.1.0 \ncompiled using version 3.16.1.0 of the Cabal library (in-tree)", + "haskell_benchmark_binary": "/Users/a123/CodingProjects/dtmc/dist-newstyle/build/aarch64-osx/ghc-9.10.3/dtmc-0.2.0.0/b/dtmc-bench/opt/build/dtmc-bench/dtmc-bench", + "haskell_benchmark_linkage": "/Users/a123/CodingProjects/dtmc/dist-newstyle/build/aarch64-osx/ghc-9.10.3/dtmc-0.2.0.0/b/dtmc-bench/opt/build/dtmc-bench/dtmc-bench:\n\t/usr/lib/libSystem.B.dylib (compatibility version 1.0.0, current version 1351.0.0)\n\t/System/Library/Frameworks/Accelerate.framework/Versions/A/Frameworks/vecLib.framework/Versions/A/libBLAS.dylib (compatibility version 1.0.0, current version 1.0.0)\n\t/System/Library/Frameworks/Accelerate.framework/Versions/A/Frameworks/vecLib.framework/Versions/A/libLAPACK.dylib (compatibility version 1.0.0, current version 1.0.0)\n\t/usr/lib/libiconv.2.dylib (compatibility version 7.0.0, current version 7.0.0)\n\t/usr/lib/libffi.dylib (compatibility version 1.0.0, current version 40.0.0)\n\t/System/Library/Frameworks/Security.framework/Versions/A/Security (compatibility version 1.0.0, current version 61439.120.27)\n\t/usr/lib/libcharset.1.dylib (compatibility version 1.0.0, current version 1.0.0)", + "haskell_options": [ + "-O2", + "-threaded", + "-rtsopts" + ], + "cabal_freeze_sha256": "a5defccf9dd5c343d47bcc3b149f66470c14bdf6e9c6ebc1f01b925b7ac036cd", + "python_lock_sha256": "e86309826e1e02112e05208e9cc26ad65c958855fcb0e74461e49c2b922d048e", + "dataset_spec_sha256": "e1be2e0ff4d0ac1618aaa434e2676aa5af6c04a76ee556e286eba16214c7eda1", + "dataset_manifest_sha256": "8e127b4d9565e66db49843b1e9dc3673ed6fc38026a9f8edc0875b629dd6af1d", + "git_commit": "daf5d56d8b7967ced2274dfee0c73f2bacb997ff", + "git_status": "?? benchmark-full-20260913-000643.log\n?? benchmark-smoke-20260913-000643.log\n?? benchmark/backups/", + "thread_environment": { + "OPENBLAS_NUM_THREADS": "1", + "OMP_NUM_THREADS": "1", + "MKL_NUM_THREADS": "1", + "VECLIB_MAXIMUM_THREADS": "1", + "NUMEXPR_NUM_THREADS": "1", + "MPLCONFIGDIR": "/Users/a123/CodingProjects/dtmc/benchmark/.cache/matplotlib", + "XDG_CACHE_HOME": "/Users/a123/CodingProjects/dtmc/benchmark/.cache", + "MPLBACKEND": "Agg" + }, + "benchmark_scope": "complete suite" +} diff --git a/benchmark/results/plots/absorbing--hitting-bounded-exact-k-100--speed-ratio.svg b/benchmark/results/plots/absorbing--hitting-bounded-exact-k-100--speed-ratio.svg new file mode 100644 --- /dev/null +++ b/benchmark/results/plots/absorbing--hitting-bounded-exact-k-100--speed-ratio.svg @@ -0,0 +1,1327 @@ + + + + + + + + 2026-09-14T10:18:43.237906 + image/svg+xml + + + Matplotlib v3.10.6, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/benchmark/results/plots/dense--evolution-one-step--speed-ratio.svg b/benchmark/results/plots/dense--evolution-one-step--speed-ratio.svg new file mode 100644 --- /dev/null +++ b/benchmark/results/plots/dense--evolution-one-step--speed-ratio.svg @@ -0,0 +1,1525 @@ + + + + + + + + 2026-09-14T10:18:45.532830 + image/svg+xml + + + Matplotlib v3.10.6, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/benchmark/results/plots/dense--hitting-time-cold-all-states--speed-ratio.svg b/benchmark/results/plots/dense--hitting-time-cold-all-states--speed-ratio.svg new file mode 100644 --- /dev/null +++ b/benchmark/results/plots/dense--hitting-time-cold-all-states--speed-ratio.svg @@ -0,0 +1,1290 @@ + + + + + + + + 2026-09-14T10:18:46.321903 + image/svg+xml + + + Matplotlib v3.10.6, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/benchmark/results/plots/periodic--finite-time-observation-k-100--speed-ratio.svg b/benchmark/results/plots/periodic--finite-time-observation-k-100--speed-ratio.svg new file mode 100644 --- /dev/null +++ b/benchmark/results/plots/periodic--finite-time-observation-k-100--speed-ratio.svg @@ -0,0 +1,1315 @@ + + + + + + + + 2026-09-14T10:18:53.479313 + image/svg+xml + + + Matplotlib v3.10.6, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/benchmark/results/ratio-summary.csv b/benchmark/results/ratio-summary.csv new file mode 100644 --- /dev/null +++ b/benchmark/results/ratio-summary.csv @@ -0,0 +1,933 @@ +family,size,operation,geometric_median_pydtmc_over_dtmc,ci95_low,ci95_high,datasets +absorbing,10,absorption-time,9.596054817634835,9.45558475240783,9.961425803768279,3 +absorbing,10,absorption/probabilities,9.42038873375433,9.26672434739029,9.471026356361355,3 +absorbing,10,construction/public-consumed,58.5497801014434,58.47297183810735,59.7458810067725,3 +absorbing,10,evolution/k-10,31.392611387358116,31.26338922046668,31.511938258213995,3 +absorbing,10,evolution/k-100,84.85715633105696,84.41113959175364,84.97041470327916,3 +absorbing,10,evolution/one-step,121.14601585774419,120.3685410461582,122.45469118857136,3 +absorbing,10,finite-time/n-step/k-10,16.97768289034936,16.960427866568516,17.11272127214238,3 +absorbing,10,finite-time/n-step/k-100,14.91672512616429,14.825530828233529,15.14810639953888,3 +absorbing,10,finite-time/observation/k-10,14.882886470733347,14.877925998828053,14.930784011106326,3 +absorbing,10,finite-time/observation/k-100,14.383750364908437,14.333028845229874,14.562716805870393,3 +absorbing,10,finite-time/step,1.1620726089477362,1.1561888459873055,1.1666401389810346,3 +absorbing,10,fundamental-matrix,7.6899486122315315,7.260083646967826,7.755665271720603,3 +absorbing,10,hitting-probability/cold-all-states,2.661509405507161,2.6289190784755085,2.67176177654515,3 +absorbing,10,hitting-time/cold-all-states,6.220454768929478,6.195325126923157,6.2531533372645,3 +absorbing,10,hitting/bounded/at-most/k-10,13.196130561211056,13.072963909839112,13.324608482610152,3 +absorbing,10,hitting/bounded/at-most/k-100,17.865618792642387,17.746174283601647,17.87981840076335,3 +absorbing,10,hitting/bounded/exact/k-10,13.000728682174957,12.868563912709723,13.050247798078722,3 +absorbing,10,hitting/bounded/exact/k-100,17.975832863429485,17.766983457948896,18.452382134065815,3 +absorbing,10,hitting/bounded/greater-than/k-10,13.47562672400248,13.43007485569362,13.676738300121354,3 +absorbing,10,hitting/bounded/greater-than/k-100,17.90109021229908,17.758878493639315,18.171290015447376,3 +absorbing,10,occupation-matrix,20.938601063552262,20.901607855923714,21.142505329183205,3 +absorbing,10,power/10,71.36010332259028,70.66847830533746,71.73389807271971,3 +absorbing,10,power/100,54.998122087231316,54.86281275432155,55.909593439883636,3 +absorbing,10,power/2,93.31775901401527,92.12967545583236,93.58993495203465,3 +absorbing,10,return/bounded/k-10,14.409170551127557,14.39900826608067,14.583768403794085,3 +absorbing,10,return/bounded/k-100,18.13290706084094,17.678107477586565,18.569548117081258,3 +absorbing,10,stationary,18.173615210450343,18.157236334023132,18.36609588003864,3 +absorbing,10,structure/classes-cold,8.423836723365566,8.394173657039385,9.58626987381574,3 +absorbing,10,structure/classes-lifecycle,50.5133912453012,50.321628855290804,52.07989567559054,3 +absorbing,10,structure/classes-warm/access,25.169001402684138,25.12716012434877,25.342193765804684,3 +absorbing,10,structure/classes-warm/consumed,22.448107408721576,22.23337903394155,22.57685182251787,3 +absorbing,10,structure/irreducible-cold,12.384043048906234,12.251389987017411,12.839399168561105,3 +absorbing,10,structure/irreducible-warm,23.904969743681114,23.602150656836955,23.963544545536394,3 +absorbing,10,visits/bounded-expectation/k-10,3.878924262002852,3.8486939544166345,3.9237722022655706,3 +absorbing,10,visits/bounded-expectation/k-100,2.120233470969715,2.1069027331374857,2.1318977144283995,3 +absorbing,25,absorption-time,9.131438854206282,9.065879584785673,9.222388695995848,3 +absorbing,25,absorption/probabilities,9.76523138834732,9.753981237385949,9.952582137459625,3 +absorbing,25,construction/public-consumed,27.140558506033535,27.094184857414824,27.183178040065037,3 +absorbing,25,evolution/k-10,27.8849631229418,27.776704270898303,27.939099685181443,3 +absorbing,25,evolution/k-100,31.929984892722103,28.361527070278296,32.32209510901886,3 +absorbing,25,evolution/one-step,107.25391524797925,106.87593179398193,108.01840149275021,3 +absorbing,25,finite-time/n-step/k-10,17.02167530101059,16.810588269207603,17.17267136503694,3 +absorbing,25,finite-time/n-step/k-100,11.447445528753724,11.401571760811487,11.487651985177958,3 +absorbing,25,finite-time/observation/k-10,14.034658929342452,13.999532624374323,14.35239806602099,3 +absorbing,25,finite-time/observation/k-100,11.164040024408493,11.095100482045662,11.214457718370268,3 +absorbing,25,finite-time/step,1.5726612567400917,1.5694031862336744,1.5933539128740202,3 +absorbing,25,fundamental-matrix,6.77911176853103,6.636017519892393,6.835701925611518,3 +absorbing,25,hitting-probability/cold-all-states,1.5388506592003535,1.537505300221586,1.5711894069746997,3 +absorbing,25,hitting-time/cold-all-states,3.4033899228395676,3.3669808357475177,3.4235294160978147,3 +absorbing,25,hitting/bounded/at-most/k-10,14.194758564890742,13.008254312150044,15.013521548929452,3 +absorbing,25,hitting/bounded/at-most/k-100,20.17126107948861,19.945159466507082,21.050168651220773,3 +absorbing,25,hitting/bounded/exact/k-10,14.275219579715381,13.890818117773865,14.832977958902768,3 +absorbing,25,hitting/bounded/exact/k-100,20.524204757725997,20.405704281118602,23.25394176849149,3 +absorbing,25,hitting/bounded/greater-than/k-10,15.229650832053217,14.438262108287987,15.29977040461895,3 +absorbing,25,hitting/bounded/greater-than/k-100,20.02468721197017,19.965823073538687,20.233165845262864,3 +absorbing,25,occupation-matrix,24.51636356031884,24.436170772189364,24.60750453299251,3 +absorbing,25,power/10,32.63463429965234,32.49217128572073,32.66229606960314,3 +absorbing,25,power/100,26.989530852942035,26.545394458888026,27.248872204829947,3 +absorbing,25,power/2,40.90052980231152,40.59596710965171,41.16029479773523,3 +absorbing,25,return/bounded/k-10,15.917289697387353,15.897685272866191,16.392544364609275,3 +absorbing,25,return/bounded/k-100,20.488288113245652,20.19358896342461,20.648102898020866,3 +absorbing,25,stationary,22.283813422046517,21.882511156390258,22.646494838185045,3 +absorbing,25,structure/classes-cold,11.51305880453658,11.333835756565323,11.823785160872598,3 +absorbing,25,structure/classes-lifecycle,23.639337534884586,23.372327678319166,23.64359971982461,3 +absorbing,25,structure/classes-warm/access,25.216487010939847,23.749697008508402,25.581818908104495,3 +absorbing,25,structure/classes-warm/consumed,15.664766503689458,15.581622888928528,15.675454554157806,3 +absorbing,25,structure/irreducible-cold,14.981623411934883,14.760836443916691,15.108617610192422,3 +absorbing,25,structure/irreducible-warm,23.79197809030587,23.767376664984706,23.835901681836695,3 +absorbing,25,visits/bounded-expectation/k-10,5.229914134405807,5.182997690655519,5.243829222595943,3 +absorbing,25,visits/bounded-expectation/k-100,2.220474620138966,2.1780896016535722,2.2248212915323045,3 +absorbing,50,absorption-time,8.207261869164025,8.169703024456961,8.314387980211297,3 +absorbing,50,absorption/probabilities,9.63775724520001,9.46520578745596,9.879758526087072,3 +absorbing,50,construction/public-consumed,22.690539806884896,22.566321912314923,22.857995277039013,3 +absorbing,50,evolution/k-10,20.105941555095725,20.090588823429293,20.17587223853938,3 +absorbing,50,evolution/k-100,15.56383609521243,15.536209541413854,15.665262125578838,3 +absorbing,50,evolution/one-step,85.69565003591893,78.50479037981178,85.97865628827304,3 +absorbing,50,finite-time/n-step/k-10,15.019375246293468,14.927385510711247,15.033809739635792,3 +absorbing,50,finite-time/n-step/k-100,7.409163790893877,7.265729841450739,7.450279257986245,3 +absorbing,50,finite-time/observation/k-10,11.978090594498802,11.897075067565337,11.985414437963739,3 +absorbing,50,finite-time/observation/k-100,7.142497296803202,7.139785605019682,7.146945792742463,3 +absorbing,50,finite-time/step,1.9694687970954081,1.8880514585766561,2.017108527625137,3 +absorbing,50,fundamental-matrix,5.867982453604838,5.84710233238063,5.9397942243530055,3 +absorbing,50,hitting-probability/cold-all-states,1.317306673304277,1.3123987420735628,1.3186843827342019,3 +absorbing,50,hitting-time/cold-all-states,2.7376162605681564,2.7354963210498267,2.7514049123282986,3 +absorbing,50,hitting/bounded/at-most/k-10,12.960273156013606,12.759038094284179,13.120538766522342,3 +absorbing,50,hitting/bounded/at-most/k-100,16.511772928613595,16.18026139799287,16.622176755966603,3 +absorbing,50,hitting/bounded/exact/k-10,12.901170944593042,12.728363315352226,14.794238598944487,3 +absorbing,50,hitting/bounded/exact/k-100,16.616811745520007,16.284923874647053,16.86645611311775,3 +absorbing,50,hitting/bounded/greater-than/k-10,13.01817415966087,12.874693153851663,13.022494062715237,3 +absorbing,50,hitting/bounded/greater-than/k-100,16.595210791636692,16.48940393347265,16.620262918752402,3 +absorbing,50,occupation-matrix,24.366576622336314,24.305553523772367,24.405933900798683,3 +absorbing,50,power/10,28.714877146619546,26.036767627163503,28.858290085351843,3 +absorbing,50,power/100,24.006951319274805,23.880436288784917,24.19237170258372,3 +absorbing,50,power/2,33.355452846502196,33.30743445945382,33.38241758182089,3 +absorbing,50,return/bounded/k-10,14.830990329099924,14.560997241023827,14.861041881689292,3 +absorbing,50,return/bounded/k-100,16.626858509982334,15.957652204580983,16.998595195930353,3 +absorbing,50,stationary,24.5111484627047,24.473270292628868,24.777072517798214,3 +absorbing,50,structure/classes-cold,13.132483460756358,13.058045244619372,13.34374315798667,3 +absorbing,50,structure/classes-lifecycle,19.248789491311765,19.214694497556238,19.381188302094657,3 +absorbing,50,structure/classes-warm/access,25.317265690839914,25.270151323356785,25.379610288657393,3 +absorbing,50,structure/classes-warm/consumed,12.691834152500526,12.311463771105812,12.706998911853193,3 +absorbing,50,structure/irreducible-cold,14.935004220973335,14.789543759315734,15.140005377207263,3 +absorbing,50,structure/irreducible-warm,23.9517913314551,23.907400258292075,23.99694824527575,3 +absorbing,50,visits/bounded-expectation/k-10,6.280853195993583,6.257552932628467,6.346129992791766,3 +absorbing,50,visits/bounded-expectation/k-100,2.0253842794194483,2.016648705437416,2.029559437510722,3 +absorbing,100,absorption-time,7.63123088304443,7.51489572265085,7.6833032216144765,3 +absorbing,100,absorption/probabilities,9.525258570011712,9.344836071617733,9.527464763946032,3 +absorbing,100,construction/public-consumed,21.53638774969152,21.42982437696184,21.85319482390747,3 +absorbing,100,evolution/k-10,13.782250992146217,13.738702957818022,13.884458410330117,3 +absorbing,100,evolution/k-100,4.659695592114022,4.653856228453342,4.6602024023443755,3 +absorbing,100,evolution/one-step,66.98021102608566,62.39286207725885,67.16850455671913,3 +absorbing,100,finite-time/n-step/k-10,11.508504617428196,10.9926014136276,11.60233713650604,3 +absorbing,100,finite-time/n-step/k-100,4.551921748336093,4.550264700819336,4.599910334999508,3 +absorbing,100,finite-time/observation/k-10,9.583255556291508,9.177001287162334,9.632874018105984,3 +absorbing,100,finite-time/observation/k-100,4.4473886075106,4.430609731841902,4.910323802536174,3 +absorbing,100,finite-time/step,3.5290245761515235,3.448305007555995,3.9367660123223382,3 +absorbing,100,fundamental-matrix,5.254377825029163,5.187473723837208,5.264985411572528,3 +absorbing,100,hitting-probability/cold-all-states,1.8501008449372156,1.848433459897863,1.8526028370865673,3 +absorbing,100,hitting-time/cold-all-states,3.7594795649171537,3.7488932014344907,3.760058245929437,3 +absorbing,100,hitting/bounded/at-most/k-10,12.664443948829453,11.967234762579073,12.70187657231019,3 +absorbing,100,hitting/bounded/at-most/k-100,16.4671275412379,15.49643126253659,16.629895423980365,3 +absorbing,100,hitting/bounded/exact/k-10,12.748263351729035,12.71427184977732,14.264130818562666,3 +absorbing,100,hitting/bounded/exact/k-100,16.561814803684907,16.478394557664878,16.587123371866245,3 +absorbing,100,hitting/bounded/greater-than/k-10,12.459853166068664,12.15166628065049,12.832997787338417,3 +absorbing,100,hitting/bounded/greater-than/k-100,16.46567725551467,16.403151143942733,16.562121851421654,3 +absorbing,100,occupation-matrix,20.021564103958053,19.975240279709517,20.06426113961099,3 +absorbing,100,power/10,28.48786571444296,28.048209496108825,29.067080734453825,3 +absorbing,100,power/100,22.94965219120039,22.91946571460804,23.05625048541852,3 +absorbing,100,power/2,35.24283577825407,35.186740274418206,35.96039434433907,3 +absorbing,100,return/bounded/k-10,14.119400110367438,13.380972682488448,18.915268350163014,3 +absorbing,100,return/bounded/k-100,16.821120315184242,16.795110621279626,16.862456251065787,3 +absorbing,100,stationary,23.527324492623304,23.520838367763588,23.96049805713125,3 +absorbing,100,structure/classes-cold,13.015994238912677,12.910491717024408,13.029254195990854,3 +absorbing,100,structure/classes-lifecycle,16.109732966992564,16.083280097472194,16.22451142481238,3 +absorbing,100,structure/classes-warm/access,25.25983094381814,25.145327574976772,25.361799386155358,3 +absorbing,100,structure/classes-warm/consumed,11.339067704393024,11.329120122175102,11.344593724907206,3 +absorbing,100,structure/irreducible-cold,13.934811128772767,13.880968131851368,14.178067286143433,3 +absorbing,100,structure/irreducible-warm,24.04488123220437,24.030728469200014,24.189169553743877,3 +absorbing,100,visits/bounded-expectation/k-10,6.394785497476969,6.06238046945123,6.426483002626237,3 +absorbing,100,visits/bounded-expectation/k-100,1.8281991729940232,1.8277875655284914,1.8388960293594638,3 +absorbing,250,absorption-time,5.409308454965462,5.405407314042524,5.500747514209653,3 +absorbing,250,absorption/probabilities,8.92728938416644,8.733848057701769,8.97079923119597,3 +absorbing,250,construction/public-consumed,15.056337192711258,15.011986208760717,15.22498313055458,3 +absorbing,250,evolution/k-10,5.37542680326768,5.294720740659737,5.5679659430642605,3 +absorbing,250,evolution/k-100,1.7821653287622055,1.7793007548739983,1.7971434447923043,3 +absorbing,250,evolution/one-step,34.6420236480178,34.52282924768032,38.21919811414531,3 +absorbing,250,fundamental-matrix,4.432377491828909,4.269317178213401,4.484757474145257,3 +absorbing,250,hitting-probability/cold-all-states,2.925499024223099,2.8694073349197913,2.927688980311017,3 +absorbing,250,hitting-time/cold-all-states,5.800338293052049,5.666093854018266,5.835483086379581,3 +absorbing,250,occupation-matrix,14.979404926585659,14.600850075667545,15.763131279462367,3 +absorbing,250,power/10,25.63824459817618,25.58615856080174,26.260978212201113,3 +absorbing,250,power/100,18.546869191180228,18.34970035236642,18.638925863826334,3 +absorbing,250,power/2,35.20115311427803,35.180907706639644,35.27586156853484,3 +absorbing,250,stationary,21.794101579780072,21.494745933778635,22.115941656376616,3 +absorbing,250,structure/classes-cold,11.972643992120952,11.887400669325148,11.997027003900737,3 +absorbing,250,structure/classes-lifecycle,11.060723039059315,10.971094432662017,11.09448025192105,3 +absorbing,250,structure/classes-warm/access,24.224123578121695,23.417706375202616,25.333068584460058,3 +absorbing,250,structure/classes-warm/consumed,10.74195664566649,10.22012255418766,10.74442932629967,3 +absorbing,250,structure/irreducible-cold,12.137840405865422,11.972242563593383,12.225344664452892,3 +absorbing,250,structure/irreducible-warm,23.787346727558454,23.52487380830844,23.799569678837965,3 +absorbing,500,absorption-time,3.179775399615866,3.0975200386136943,3.2335912762043613,3 +absorbing,500,absorption/probabilities,4.266060849116532,4.099799557852052,4.428709774945363,3 +absorbing,500,construction/public-consumed,11.111980435726952,10.545913310323701,11.333220912645652,3 +absorbing,500,evolution/k-10,3.502990420240271,3.439665387197909,3.5649239030843654,3 +absorbing,500,evolution/k-100,1.4015498993666111,1.3967963726705295,1.4019314560895,3 +absorbing,500,evolution/one-step,22.414467546005916,22.106959906561606,22.42702702647602,3 +absorbing,500,fundamental-matrix,3.343858729482268,3.182616911438281,3.34869423874261,3 +absorbing,500,hitting-probability/cold-all-states,2.9841791296701725,2.9460836369470598,2.998172706683375,3 +absorbing,500,hitting-time/cold-all-states,5.9844555293958015,5.166460397067625,6.04006010614908,3 +absorbing,500,power/10,18.018924545663403,17.784244298358075,18.287541617281118,3 +absorbing,500,power/100,11.306740559825789,11.303121071063897,11.399851130056785,3 +absorbing,500,power/2,28.230324393145448,27.424734144184814,28.941043512826322,3 +absorbing,500,stationary,11.942480482128907,11.014255441033846,12.054973358073768,3 +absorbing,500,structure/classes-cold,6.117284546028949,5.3637015191930315,6.394207890101479,3 +absorbing,500,structure/classes-lifecycle,7.706091343606844,7.691460582106316,7.859205296386526,3 +absorbing,500,structure/classes-warm/access,25.10670309966576,23.946845358946902,25.150496061342736,3 +absorbing,500,structure/classes-warm/consumed,11.341502115061994,10.951674704568362,11.345495307437085,3 +absorbing,500,structure/irreducible-cold,5.9035470510052965,5.883415300900271,5.93746452168599,3 +absorbing,500,structure/irreducible-warm,23.662777853627272,23.60834558041817,23.69976690732699,3 +absorbing,1000,construction/public-consumed,10.25794672626904,10.212161359731182,10.500006583681431,3 +absorbing,1000,evolution/k-10,1.5927914596429942,1.5791915804435857,2.0411711654113205,3 +absorbing,1000,evolution/k-100,0.887851395498483,0.8861036061453018,1.0812387118169164,3 +absorbing,1000,evolution/one-step,8.210922585013453,8.149753520363927,11.597469659870326,3 +absorbing,1000,structure/classes-cold,3.3914552148642927,3.36241688654659,3.4235979976065427,3 +absorbing,1000,structure/classes-lifecycle,6.4265468880393115,5.99535263349096,6.440866989455148,3 +absorbing,1000,structure/classes-warm/access,25.000283904749132,24.69961619271101,25.06099823582058,3 +absorbing,1000,structure/classes-warm/consumed,11.63631814589593,11.628062666533587,11.656454753446235,3 +absorbing,1000,structure/irreducible-cold,3.3970948481080114,3.1975561192739113,3.4686126708766944,3 +absorbing,1000,structure/irreducible-warm,23.463552022207423,23.35125402978758,23.542376102738864,3 +dense,10,construction/public-consumed,59.909668244555036,56.052700780899016,66.17863505698352,3 +dense,10,evolution/k-10,29.309195850836367,29.276202123657615,32.71277675227978,3 +dense,10,evolution/k-100,80.41382664822007,77.34934939802856,83.12117794355002,3 +dense,10,evolution/one-step,122.44172399900992,118.43669418678421,145.43410812881825,3 +dense,10,finite-time/n-step/k-10,18.542982908516507,16.103929232784093,19.72811945727098,3 +dense,10,finite-time/n-step/k-100,15.19520883933233,14.369580253728659,15.73394410913115,3 +dense,10,finite-time/observation/k-10,15.156922194964153,13.505337251629687,16.41100632414782,3 +dense,10,finite-time/observation/k-100,14.714296184548875,13.910113951136408,14.95599946688845,3 +dense,10,finite-time/step,1.2707891760877528,1.2574859002486234,1.2812692778403292,3 +dense,10,hitting-probability/cold-all-states,2.7160920942664615,2.5636298687413355,3.0679462649163147,3 +dense,10,hitting-time/cold-all-states,5.699890641009064,5.66628928357805,6.142474109085361,3 +dense,10,hitting/bounded/at-most/k-10,12.779871672408973,12.749642735563183,14.752056643030135,3 +dense,10,hitting/bounded/at-most/k-100,17.5145494907514,16.50944758426099,18.843797121343016,3 +dense,10,hitting/bounded/exact/k-10,13.368162702798314,11.312385966039953,15.17832753512651,3 +dense,10,hitting/bounded/exact/k-100,17.735942274364383,17.128130751953975,19.178942493954338,3 +dense,10,hitting/bounded/greater-than/k-10,12.999125962816134,12.877592673494044,14.940400018242977,3 +dense,10,hitting/bounded/greater-than/k-100,17.120793704518025,16.954029896718886,17.360735247936173,3 +dense,10,power/10,68.42398572119556,66.91318648300806,69.07597709885056,3 +dense,10,power/100,57.02119497164542,56.81885397973887,57.33058317013018,3 +dense,10,power/2,88.6622407407919,86.05061077456742,94.19270834677181,3 +dense,10,race/forward-committor,16.001841509122716,14.40132583349519,18.062826248354643,3 +dense,10,return/bounded/k-10,14.887744656009087,14.101119924591258,15.456953109615306,3 +dense,10,return/bounded/k-100,17.60014126444214,17.463018764147435,17.602477059647118,3 +dense,10,return/mean-recurrence,35.55283025544416,35.06729304063154,41.05966926605536,3 +dense,10,simulation/10000,11.888277527417744,11.601843636397724,12.302792823121907,3 +dense,10,simulation/100000,11.95047546746257,10.47032335460452,12.206871002035767,3 +dense,10,stationary,12.36356307538299,11.259924003501268,13.152455637376718,3 +dense,10,structure/classes-cold,9.95509831451682,9.81809909152274,9.965620658094078,3 +dense,10,structure/classes-lifecycle,51.15165412922631,50.139937802253534,53.028617306740465,3 +dense,10,structure/classes-warm/access,24.552771749376102,24.509033956634664,25.1541835052202,3 +dense,10,structure/classes-warm/consumed,22.992410058627136,22.49381495570006,23.92490642972152,3 +dense,10,structure/irreducible-cold,13.303815135878626,13.097224198234228,13.80639136484897,3 +dense,10,structure/irreducible-warm,23.001392344867835,22.98847417299123,23.284365576245992,3 +dense,10,visits/bounded-expectation/k-10,4.091435674765659,4.0579212717924955,4.7030139499285015,3 +dense,10,visits/bounded-expectation/k-100,2.0407393117229136,2.0378838854111425,2.081309796185928,3 +dense,25,construction/public-consumed,32.36713844774368,28.779972011993543,36.71871496678462,3 +dense,25,evolution/k-10,32.1378943028111,31.0953820188968,43.999993914166254,3 +dense,25,evolution/k-100,29.34223992288828,28.904509321756482,35.342547188833215,3 +dense,25,evolution/one-step,128.36361449256964,116.43904381881404,174.04948239492347,3 +dense,25,finite-time/n-step/k-10,17.498314152151554,4.508545056094992,23.68606447249653,3 +dense,25,finite-time/n-step/k-100,3.232086537995935,2.900170938463302,13.686498993467021,3 +dense,25,finite-time/observation/k-10,7.907071713898021,4.970152148614677,20.33278378420255,3 +dense,25,finite-time/observation/k-100,12.916143349009216,11.200331472874511,13.503390420725129,3 +dense,25,finite-time/step,2.998429242465993,0.465389877178871,3.861282020402908,3 +dense,25,hitting-probability/cold-all-states,1.7529326551882176,0.7677094011668764,2.081392819658483,3 +dense,25,hitting-time/cold-all-states,3.920470031723169,0.6260354656890889,4.100519822438418,3 +dense,25,hitting/bounded/at-most/k-10,14.932185144272914,14.038702205629821,19.19612937172748,3 +dense,25,hitting/bounded/at-most/k-100,21.017490971991908,20.129516414430963,21.8527369267896,3 +dense,25,hitting/bounded/exact/k-10,16.352999114109384,13.4099178294943,18.570158191295413,3 +dense,25,hitting/bounded/exact/k-100,20.954316436871345,19.077187141443744,26.971022468769053,3 +dense,25,hitting/bounded/greater-than/k-10,16.070167208440004,14.876781208024276,16.716282912461466,3 +dense,25,hitting/bounded/greater-than/k-100,21.542673792336196,19.46622254331408,21.82294167582613,3 +dense,25,power/10,39.05175505980486,27.997538935302213,42.415160736924456,3 +dense,25,power/100,27.982098125957616,24.092361881190808,37.168405094232746,3 +dense,25,power/2,48.10282463933765,42.722949605676675,49.22218316583518,3 +dense,25,race/forward-committor,21.473527590713672,4.668514111296473,22.58094964223752,3 +dense,25,return/bounded/k-10,18.88824525407535,15.59081244885344,20.862370421801607,3 +dense,25,return/bounded/k-100,18.8365137071295,15.913656520405434,20.326067524274126,3 +dense,25,return/mean-recurrence,41.34642750116992,39.222640225402024,41.73446101123269,3 +dense,25,simulation/10000,12.074043267590364,11.74585715516719,12.108730414020894,3 +dense,25,simulation/100000,12.058616181090068,10.954687833817264,12.687013480099175,3 +dense,25,stationary,13.615192603397949,6.270367149586343,15.729070718409966,3 +dense,25,structure/classes-cold,11.724567480162543,9.115823430432904,13.990421113689317,3 +dense,25,structure/classes-lifecycle,27.398900258494834,16.287203977421818,31.709922601581674,3 +dense,25,structure/classes-warm/access,28.491151745244412,20.01773276435293,29.062970473667583,3 +dense,25,structure/classes-warm/consumed,16.949941271181213,11.552455952316647,22.979077329202592,3 +dense,25,structure/irreducible-cold,15.064132846033075,9.91083250031518,21.535239068786577,3 +dense,25,structure/irreducible-warm,27.108582676570357,13.560011951994769,28.23521830138801,3 +dense,25,visits/bounded-expectation/k-10,5.187850287109283,4.657005738604992,5.88202377682921,3 +dense,25,visits/bounded-expectation/k-100,2.2257782076074717,2.2047386599482306,2.359595531120969,3 +dense,50,construction/public-consumed,22.551819995100065,22.25629771809942,24.38512920010499,3 +dense,50,evolution/k-10,21.964137092335797,15.892589307360636,24.240189645384756,3 +dense,50,evolution/k-100,14.865631462856062,14.102217526694295,16.17977458844679,3 +dense,50,evolution/one-step,107.01302239755131,91.8850689741085,117.94409084830042,3 +dense,50,finite-time/n-step/k-10,14.475342265853385,12.46741103409077,18.30272882199298,3 +dense,50,finite-time/n-step/k-100,7.0608051464254356,6.496499943104623,7.548359799447794,3 +dense,50,finite-time/observation/k-10,14.11490761847,14.068935562122764,14.338591242775147,3 +dense,50,finite-time/observation/k-100,7.180727085214977,6.93093146302522,7.933706905720658,3 +dense,50,finite-time/step,3.5896487199115508,2.928580312798497,4.729138885506494,3 +dense,50,hitting-probability/cold-all-states,1.59411989597951,1.4495327198353747,1.884108412543613,3 +dense,50,hitting-time/cold-all-states,2.687263212303513,2.537027964137271,3.2675619473208486,3 +dense,50,hitting/bounded/at-most/k-10,14.74786064969561,13.696191796967831,20.597080955602916,3 +dense,50,hitting/bounded/at-most/k-100,15.616103127204214,13.848963218697959,17.46782478844333,3 +dense,50,hitting/bounded/exact/k-10,14.108307122249233,10.949211788321877,16.33406977094889,3 +dense,50,hitting/bounded/exact/k-100,16.607771733221895,15.409484131042044,16.66642298556619,3 +dense,50,hitting/bounded/greater-than/k-10,13.369622205507792,11.325729988586462,14.700984099999353,3 +dense,50,hitting/bounded/greater-than/k-100,15.018756618821733,14.729093698208409,17.946519288091654,3 +dense,50,power/10,29.027677342097874,27.475215682228715,29.993022806999658,3 +dense,50,power/100,23.164478442947146,20.693336473182587,24.394924716238407,3 +dense,50,power/2,34.711562885129574,33.79709974366411,44.58450865479954,3 +dense,50,race/forward-committor,19.90350015780259,17.3991441739417,20.165119083127347,3 +dense,50,return/bounded/k-10,15.59326827113891,14.490260590741293,18.981688394082788,3 +dense,50,return/bounded/k-100,17.653534065113647,16.20292737125323,17.895355133422857,3 +dense,50,return/mean-recurrence,29.684530309416136,28.448617245489203,30.22747848279397,3 +dense,50,simulation/10000,13.549841456866258,13.25861098792383,13.860516808218977,3 +dense,50,simulation/100000,12.145344174593422,11.76019915031342,13.331280752588953,3 +dense,50,stationary,8.108431269014424,6.981616146269536,8.748806754416544,3 +dense,50,structure/classes-cold,12.022967657157844,10.688442059201602,17.364660145471152,3 +dense,50,structure/classes-lifecycle,18.420579198360763,17.416960722774085,19.55906682068844,3 +dense,50,structure/classes-warm/access,23.460582999171525,19.054744874299068,23.492620423658124,3 +dense,50,structure/classes-warm/consumed,11.852991330185253,9.692692840928174,14.541761922856578,3 +dense,50,structure/irreducible-cold,15.333999217699517,12.735667902390473,15.788456345054046,3 +dense,50,structure/irreducible-warm,22.91894631678043,18.040853848275166,23.702631250465412,3 +dense,50,visits/bounded-expectation/k-10,6.932207079305862,5.455845875198222,7.768769425305297,3 +dense,50,visits/bounded-expectation/k-100,2.3456891011646444,2.1420108396568174,2.4361308809689155,3 +dense,100,construction/public-consumed,21.797894109199493,18.674714773094934,24.809609610581166,3 +dense,100,evolution/k-10,13.815861236356879,10.788163243487645,18.582394989100354,3 +dense,100,evolution/k-100,4.387802370111656,3.820734376133158,4.679329810244088,3 +dense,100,evolution/one-step,67.33369135991738,55.001816855494425,115.10741280588121,3 +dense,100,finite-time/n-step/k-10,11.499155243493577,11.420515857379856,12.630763236391088,3 +dense,100,finite-time/n-step/k-100,4.5608137773810205,4.543224703007755,4.9278223675611486,3 +dense,100,finite-time/observation/k-10,9.55426307626084,9.305381894764126,10.643340056396,3 +dense,100,finite-time/observation/k-100,4.426033021223756,4.403157189336327,4.964495352716884,3 +dense,100,finite-time/step,3.477505611907516,2.1875788967499097,6.964879020852362,3 +dense,100,hitting-probability/cold-all-states,1.7823590826382563,1.35795143219061,1.7861706683382426,3 +dense,100,hitting-time/cold-all-states,3.4746351451565918,2.624610697175846,3.638087698740626,3 +dense,100,hitting/bounded/at-most/k-10,11.585137725285813,11.32867083227696,12.448173529546713,3 +dense,100,hitting/bounded/at-most/k-100,16.336283648311525,14.227259308651517,16.431183864181033,3 +dense,100,hitting/bounded/exact/k-10,11.642293155909034,11.38084695946587,12.612277365088168,3 +dense,100,hitting/bounded/exact/k-100,16.341479752245576,16.293451287608924,16.928664959137375,3 +dense,100,hitting/bounded/greater-than/k-10,11.548289214240258,11.542321758593777,12.611901081108579,3 +dense,100,hitting/bounded/greater-than/k-100,16.321201056472383,14.398769219346347,16.3707997714562,3 +dense,100,power/10,28.5789046202207,17.824806217127286,30.9193442719622,3 +dense,100,power/100,23.09486790871578,16.983891519136172,26.91999665576896,3 +dense,100,power/2,36.306451660545505,29.634329234925655,39.8495984325245,3 +dense,100,race/forward-committor,22.720884454800306,21.11335651443274,25.25256584540948,3 +dense,100,return/bounded/k-10,14.20011558923575,13.935828698132632,14.347577023310544,3 +dense,100,return/bounded/k-100,16.715069298557076,16.25518457567171,16.808015625886483,3 +dense,100,return/mean-recurrence,17.30957622964021,17.298122170917477,17.839773826442233,3 +dense,100,simulation/10000,11.873720219751563,11.870780188341255,11.953433313098207,3 +dense,100,simulation/100000,12.618694429554989,12.300802262886883,13.073050238512515,3 +dense,100,stationary,4.318385845295006,3.71672472302708,4.603307247441586,3 +dense,100,structure/classes-cold,12.918594149814663,9.409283092562612,13.280006253085071,3 +dense,100,structure/classes-lifecycle,14.889050159742617,11.519308101638561,16.127041325011238,3 +dense,100,structure/classes-warm/access,25.152736919479096,19.898993922578818,28.28807302268086,3 +dense,100,structure/classes-warm/consumed,11.454693659546482,9.359494644254497,13.807744008095819,3 +dense,100,structure/irreducible-cold,13.699040398948716,10.804856111858545,15.109356112605065,3 +dense,100,structure/irreducible-warm,22.541901734468556,19.04928982616094,23.544587130681858,3 +dense,100,visits/bounded-expectation/k-10,6.312769933362511,6.018682680287858,6.429807248550154,3 +dense,100,visits/bounded-expectation/k-100,1.8348647526025872,1.8208342135184827,2.121596342619181,3 +dense,250,construction/public-consumed,15.198194548568564,15.14708947028119,15.863501979524305,3 +dense,250,evolution/k-10,5.583541626454323,5.345482490960224,5.86577707230986,3 +dense,250,evolution/k-100,1.8460016054770851,1.8369790141719613,1.8875153679109478,3 +dense,250,evolution/one-step,36.7045644525153,34.4133554596031,40.81572818471197,3 +dense,250,hitting-probability/cold-all-states,2.679580062999949,2.6735580512260038,2.7425627443297538,3 +dense,250,hitting-time/cold-all-states,5.25733097720396,4.627926799434584,5.401023618682491,3 +dense,250,power/10,25.686281515366247,25.644815331880178,26.49284457929857,3 +dense,250,power/100,18.76192765491338,18.400348069591054,18.78708170243482,3 +dense,250,power/2,35.80975969389664,35.65213626054521,36.19017909716977,3 +dense,250,race/forward-committor,15.351300241135876,15.2900661356941,15.399895533327665,3 +dense,250,return/mean-recurrence,7.882727957994314,7.879534430639683,8.008506284451414,3 +dense,250,simulation/10000,9.478265759190869,9.45609957281466,9.693331421854515,3 +dense,250,simulation/100000,13.582049515762534,13.551757677031055,13.662912912012436,3 +dense,250,stationary,2.3409336927136577,2.296783827632259,2.4336588691835566,3 +dense,250,structure/classes-cold,11.605258374207438,11.572351513503804,11.838467191759436,3 +dense,250,structure/classes-lifecycle,11.043719973890644,10.80119846443695,11.31257352738351,3 +dense,250,structure/classes-warm/access,25.24855271529993,25.133133263133224,25.414545949932688,3 +dense,250,structure/classes-warm/consumed,10.820307671004272,10.814172476314777,10.835045064256432,3 +dense,250,structure/irreducible-cold,11.711828260037487,11.57191544436792,11.773881275330805,3 +dense,250,structure/irreducible-warm,22.975906636259158,22.794000505410512,23.117678141210515,3 +dense,500,construction/public-consumed,11.189059665624868,11.162937253103575,11.336883469937229,3 +dense,500,evolution/k-10,3.472109382823989,3.434104648228992,3.5423392282127826,3 +dense,500,evolution/k-100,1.4004177419673232,1.394115420691506,1.4046735841054814,3 +dense,500,evolution/one-step,22.503820380799905,22.28834507201037,22.55470389537727,3 +dense,500,hitting-probability/cold-all-states,2.635435488887555,2.61573903184528,2.6980070879013702,3 +dense,500,hitting-time/cold-all-states,5.199102764672115,4.933875127112894,5.382655776767178,3 +dense,500,power/10,18.458051947911507,18.29172311886144,18.67399607753704,3 +dense,500,power/100,11.53755992788757,11.525460110313622,11.572051005400182,3 +dense,500,power/2,29.13875343437637,28.926068058423834,29.49144734297,3 +dense,500,race/forward-committor,9.03881792472649,8.604593434863704,9.254113457136587,3 +dense,500,return/mean-recurrence,4.215667175962845,3.8793500196712856,4.2230549658340335,3 +dense,500,simulation/10000,5.331549209170485,5.2481241915034555,5.377963780619604,3 +dense,500,simulation/100000,13.737532901524272,13.573105219762514,13.95355589871611,3 +dense,500,stationary,1.4924432285161513,1.489923634937075,1.5281924015780641,3 +dense,500,structure/classes-cold,5.916190635595841,5.758496471107521,5.98554354180109,3 +dense,500,structure/classes-lifecycle,7.686801119684507,7.605001894933039,7.728966676251797,3 +dense,500,structure/classes-warm/access,25.055831012560766,25.00766583729613,25.058437899161987,3 +dense,500,structure/classes-warm/consumed,11.370611839120391,11.352983427478703,11.37898893181257,3 +dense,500,structure/irreducible-cold,5.73659310696454,5.62977358564455,5.867031190717702,3 +dense,500,structure/irreducible-warm,23.069193088756446,23.01391357553914,23.24858935137787,3 +dense,1000,construction/public-consumed,10.004955455754605,9.932437509820193,10.00627175172309,3 +dense,1000,evolution/k-10,1.9082937395404789,1.7634369918690147,1.980353388121951,3 +dense,1000,evolution/k-100,1.060676683954244,1.0137951489739232,1.0758639259788976,3 +dense,1000,evolution/one-step,9.881407898920466,9.62557312066086,10.161698546549669,3 +dense,1000,simulation/10000,2.198816914508467,2.1947945187187217,2.2449515651595706,3 +dense,1000,simulation/100000,10.829588136257907,10.654820366930094,11.077789594425326,3 +low-outdegree,10,construction/public-consumed,56.13684137368001,56.0682724529402,56.53755672076844,3 +low-outdegree,10,evolution/k-10,30.861657003412507,30.787771501066462,31.065190755205744,3 +low-outdegree,10,evolution/k-100,84.62743655485482,84.37639267136036,84.98661567582432,3 +low-outdegree,10,evolution/one-step,122.4015776812161,120.17275205947828,123.01953555960537,3 +low-outdegree,10,finite-time/n-step/k-10,17.128818925899974,16.772227008810557,17.214246909516433,3 +low-outdegree,10,finite-time/n-step/k-100,14.91702479825646,14.717170671594916,15.025570005603084,3 +low-outdegree,10,finite-time/observation/k-10,14.786010462492676,14.774855417373937,15.039406665803511,3 +low-outdegree,10,finite-time/observation/k-100,14.395201496962537,14.323569482887917,14.747897723545016,3 +low-outdegree,10,finite-time/step,1.1447603175628727,1.1160813720394982,1.1624204944648735,3 +low-outdegree,10,hitting-probability/cold-all-states,2.6484359218895763,2.6383611691440776,2.6540988631107347,3 +low-outdegree,10,hitting-time/cold-all-states,6.131472406878279,6.10893611692149,6.132527252667572,3 +low-outdegree,10,hitting/bounded/at-most/k-10,13.25517546710227,12.987469614877725,13.334205051257415,3 +low-outdegree,10,hitting/bounded/at-most/k-100,17.799996322153177,17.79271707707996,18.036615606138103,3 +low-outdegree,10,hitting/bounded/exact/k-10,13.096756080989664,12.782193871790476,13.377980158279652,3 +low-outdegree,10,hitting/bounded/exact/k-100,17.689058783228436,17.663629003406804,17.900305126159516,3 +low-outdegree,10,hitting/bounded/greater-than/k-10,13.518813127718724,13.265574199858394,13.521949304081417,3 +low-outdegree,10,hitting/bounded/greater-than/k-100,17.89942918802927,17.850765451082818,17.9396794309488,3 +low-outdegree,10,power/10,72.0430068036113,71.17551862711619,72.34959455079805,3 +low-outdegree,10,power/100,56.132120330234414,54.54403957326691,56.28748509902594,3 +low-outdegree,10,power/2,92.36833676048693,92.06940222641698,96.35786434032165,3 +low-outdegree,10,race/forward-committor,14.839580497650429,14.761216616860654,15.020117907669759,3 +low-outdegree,10,return/bounded/k-10,14.560501941894472,14.242561941446892,14.639987538452628,3 +low-outdegree,10,return/bounded/k-100,18.36379602182365,18.33209890175035,18.418990413946005,3 +low-outdegree,10,return/mean-recurrence,36.58915602149434,36.12049144438704,37.11652999462448,3 +low-outdegree,10,simulation/10000,12.922539166701378,12.846862303953188,13.031727240217435,3 +low-outdegree,10,simulation/100000,12.682311959069217,12.629713688030966,12.739411777634999,3 +low-outdegree,10,stationary,11.937614641940119,11.847915362985983,12.040057595711277,3 +low-outdegree,10,structure/classes-cold,7.827863582647686,7.78503170426378,7.889981121308948,3 +low-outdegree,10,structure/classes-lifecycle,48.76863496854146,48.65792011146013,50.155477273808145,3 +low-outdegree,10,structure/classes-warm/access,25.007213639593264,24.856682142223466,25.449243401586696,3 +low-outdegree,10,structure/classes-warm/consumed,22.691025977533226,21.153773534009375,22.88737486532452,3 +low-outdegree,10,structure/irreducible-cold,11.882723224460168,11.774242021347163,11.963959719047756,3 +low-outdegree,10,structure/irreducible-warm,23.278537354813686,22.512571527953614,23.41095055919743,3 +low-outdegree,10,visits/bounded-expectation/k-10,3.8339533641270647,3.8182996466578274,3.835029542408634,3 +low-outdegree,10,visits/bounded-expectation/k-100,2.1289518989626535,2.125012099535911,2.158491552371312,3 +low-outdegree,25,construction/public-consumed,22.616119483461787,22.30851954761737,22.6762481672054,3 +low-outdegree,25,evolution/k-10,27.644359145024595,27.046967921807845,28.502949063690156,3 +low-outdegree,25,evolution/k-100,31.939579057380254,30.966447513561235,32.45572920013099,3 +low-outdegree,25,evolution/one-step,111.89801365522912,108.73548399592457,112.75587394052027,3 +low-outdegree,25,finite-time/n-step/k-10,16.829588302304185,16.765353698865688,17.037804907867994,3 +low-outdegree,25,finite-time/n-step/k-100,11.52539609764061,11.327689558386856,11.755035657621542,3 +low-outdegree,25,finite-time/observation/k-10,13.985068352548028,12.299873721917658,14.016427977781554,3 +low-outdegree,25,finite-time/observation/k-100,11.17549157005866,10.796116541200975,11.238641355363686,3 +low-outdegree,25,finite-time/step,1.4960976692089079,1.4312809678416538,1.5505432935822918,3 +low-outdegree,25,hitting-probability/cold-all-states,1.8372200705508699,1.812978330336389,1.887049642678059,3 +low-outdegree,25,hitting-time/cold-all-states,4.027495522227201,4.025532161876391,4.048125668268196,3 +low-outdegree,25,hitting/bounded/at-most/k-10,13.992271189484512,13.956692810687375,14.511938402161523,3 +low-outdegree,25,hitting/bounded/at-most/k-100,20.31607891447086,20.119147203834906,20.89167595319698,3 +low-outdegree,25,hitting/bounded/exact/k-10,14.442248471984806,13.997882948448861,14.524709557603172,3 +low-outdegree,25,hitting/bounded/exact/k-100,19.870332287198906,19.84787823401845,20.169555823365613,3 +low-outdegree,25,hitting/bounded/greater-than/k-10,14.687973320432949,14.572573540498214,15.305884832465253,3 +low-outdegree,25,hitting/bounded/greater-than/k-100,19.717691079440165,19.55480979518122,20.366922334109177,3 +low-outdegree,25,power/10,34.1386500407265,32.851496382568044,34.25704560205876,3 +low-outdegree,25,power/100,27.811610195109626,26.62336855125718,28.174775830618042,3 +low-outdegree,25,power/2,32.35366481324708,31.159326370062345,32.882983615778926,3 +low-outdegree,25,race/forward-committor,15.307200282278089,14.879097605577979,15.488597518677107,3 +low-outdegree,25,return/bounded/k-10,15.907029905564775,15.82183661339347,16.315325686312534,3 +low-outdegree,25,return/bounded/k-100,20.758030515945162,19.49528605955601,22.64515597806939,3 +low-outdegree,25,return/mean-recurrence,37.40779117388092,36.722201861367346,37.453880336030366,3 +low-outdegree,25,simulation/10000,12.9329112503366,12.771597890418642,13.144988218071969,3 +low-outdegree,25,simulation/100000,12.715644662791062,12.592285843413682,12.889497791365423,3 +low-outdegree,25,stationary,10.623831776393331,10.582091365194765,10.770371909093239,3 +low-outdegree,25,structure/classes-cold,8.767715778398676,8.622848535788272,8.961286616435128,3 +low-outdegree,25,structure/classes-lifecycle,21.595308020090442,21.591764096984917,21.63836446256062,3 +low-outdegree,25,structure/classes-warm/access,25.305347623339046,23.9163440494223,25.377095450921203,3 +low-outdegree,25,structure/classes-warm/consumed,16.274487584179187,16.205236164182818,16.382004401112024,3 +low-outdegree,25,structure/irreducible-cold,15.206682683077494,14.875420767796827,15.754560533453256,3 +low-outdegree,25,structure/irreducible-warm,23.287502304805514,23.266929639540564,23.520950589067095,3 +low-outdegree,25,visits/bounded-expectation/k-10,5.147186373324004,5.101959517776883,5.221614030419225,3 +low-outdegree,25,visits/bounded-expectation/k-100,2.19616755669018,2.168846681425263,2.198724293669152,3 +low-outdegree,50,construction/public-consumed,17.20902238387217,17.142140565206596,17.266884247979284,3 +low-outdegree,50,evolution/k-10,19.55435164063828,19.238783719742987,20.105049296587378,3 +low-outdegree,50,evolution/k-100,14.848097992593653,14.71477770283281,15.330027440131932,3 +low-outdegree,50,evolution/one-step,84.10848713561005,84.0634063980615,84.61297090095997,3 +low-outdegree,50,finite-time/n-step/k-10,14.879445066494172,14.721778275025423,15.063936264571842,3 +low-outdegree,50,finite-time/n-step/k-100,7.378605744639573,7.144706820058816,7.430328620044408,3 +low-outdegree,50,finite-time/observation/k-10,11.974816836221146,11.57476766626735,12.033227466694768,3 +low-outdegree,50,finite-time/observation/k-100,7.055404916046319,7.02149289051912,7.080055506263443,3 +low-outdegree,50,finite-time/step,1.794414132436535,1.7816761102605758,1.8347369899199315,3 +low-outdegree,50,hitting-probability/cold-all-states,1.7648286142362362,1.729709499584381,1.7884146555059424,3 +low-outdegree,50,hitting-time/cold-all-states,3.71029472213631,3.6951520184675815,3.715731795649829,3 +low-outdegree,50,hitting/bounded/at-most/k-10,12.903595367687865,12.884756067586205,12.907033189701753,3 +low-outdegree,50,hitting/bounded/at-most/k-100,17.133657304102915,17.088916162250428,17.39714505497244,3 +low-outdegree,50,hitting/bounded/exact/k-10,12.75230745040501,12.692002742978188,12.895933275079893,3 +low-outdegree,50,hitting/bounded/exact/k-100,17.028913672419197,16.94587115454687,17.292523474767385,3 +low-outdegree,50,hitting/bounded/greater-than/k-10,12.912921575905761,12.835273715280675,12.98930152226001,3 +low-outdegree,50,hitting/bounded/greater-than/k-100,16.936058123205644,16.91074861904332,17.298472344946425,3 +low-outdegree,50,power/10,28.13119133656851,27.93364520845109,29.18714518202023,3 +low-outdegree,50,power/100,24.41240801310449,23.83765839232806,24.68815438620066,3 +low-outdegree,50,power/2,17.54558073200088,17.102926099594722,17.63529988981019,3 +low-outdegree,50,race/forward-committor,14.610771677616578,14.408243475632887,14.722266770394413,3 +low-outdegree,50,return/bounded/k-10,14.763498849484225,14.743943187242456,14.775741322078744,3 +low-outdegree,50,return/bounded/k-100,17.422043988260228,17.35601469433715,17.552337910474424,3 +low-outdegree,50,return/mean-recurrence,24.354953172070466,24.342911991218475,24.561953364368957,3 +low-outdegree,50,simulation/10000,13.19487915441665,13.007243387080281,13.312453580999273,3 +low-outdegree,50,simulation/100000,13.1523758397122,12.883186096762483,13.411110454243792,3 +low-outdegree,50,stationary,6.360623444706747,6.1937918075464635,6.419707974083878,3 +low-outdegree,50,structure/classes-cold,8.971447343976951,8.964987628640621,9.030511650323495,3 +low-outdegree,50,structure/classes-lifecycle,16.835243241099633,16.539040080018793,16.905737244434416,3 +low-outdegree,50,structure/classes-warm/access,25.267706945708632,25.25058260752337,25.29001113676059,3 +low-outdegree,50,structure/classes-warm/consumed,12.87860181031052,12.846136741371605,12.917055257818234,3 +low-outdegree,50,structure/irreducible-cold,18.08908891623116,17.715898699008147,18.253889872326244,3 +low-outdegree,50,structure/irreducible-warm,23.402550450533436,22.78227728058502,23.691786534328696,3 +low-outdegree,50,visits/bounded-expectation/k-10,6.1969700310777815,6.180964276235256,6.259901165218736,3 +low-outdegree,50,visits/bounded-expectation/k-100,2.017585189240143,2.01193588458705,2.030114311264699,3 +low-outdegree,100,construction/public-consumed,15.523575835699802,15.269474123194707,15.539103828128324,3 +low-outdegree,100,evolution/k-10,13.492566551836601,13.39470681717413,13.505654570807762,3 +low-outdegree,100,evolution/k-100,4.600532454313634,4.600313629728785,4.614753458041963,3 +low-outdegree,100,evolution/one-step,65.60642818711482,65.10744402752589,66.06023557108674,3 +low-outdegree,100,finite-time/n-step/k-10,11.391650329931933,11.332274550658905,11.525927631282835,3 +low-outdegree,100,finite-time/n-step/k-100,4.451691023576952,4.417569951049268,4.499474576865876,3 +low-outdegree,100,finite-time/observation/k-10,9.352667323093533,9.345777436213536,9.369753664136947,3 +low-outdegree,100,finite-time/observation/k-100,4.3729782476901295,4.361097064802975,4.380643485079838,3 +low-outdegree,100,finite-time/step,3.184745668899098,3.1799296990531083,3.187363922768538,3 +low-outdegree,100,hitting-probability/cold-all-states,2.5980467188964473,2.569427109699544,2.611813484136657,3 +low-outdegree,100,hitting-time/cold-all-states,5.25408072489465,5.122044868377009,5.3293101707037716,3 +low-outdegree,100,hitting/bounded/at-most/k-10,11.440855395852799,11.368803263208736,11.524009125575308,3 +low-outdegree,100,hitting/bounded/at-most/k-100,16.350585924650527,16.281606280123945,16.357096073575416,3 +low-outdegree,100,hitting/bounded/exact/k-10,11.432727593092736,11.382647996329824,11.462099055761112,3 +low-outdegree,100,hitting/bounded/exact/k-100,16.339275969655787,16.219606578990764,16.435092196529077,3 +low-outdegree,100,hitting/bounded/greater-than/k-10,11.419629144594682,11.414997217366365,11.443759809491182,3 +low-outdegree,100,hitting/bounded/greater-than/k-100,16.35547837089594,16.317295698485545,16.368079739327747,3 +low-outdegree,100,power/10,28.647524870551557,28.345181909217523,28.776353264363323,3 +low-outdegree,100,power/100,22.760138010966415,21.26481954884909,22.993435071772154,3 +low-outdegree,100,power/2,11.920678473288874,11.9024290758836,11.925789131617519,3 +low-outdegree,100,race/forward-committor,15.646492444543494,15.559091138095956,15.713988231688843,3 +low-outdegree,100,return/bounded/k-10,14.27652803953391,14.203320175214039,14.280039009759852,3 +low-outdegree,100,return/bounded/k-100,16.799346424379376,16.656387574294953,16.844579440580365,3 +low-outdegree,100,return/mean-recurrence,11.55176307342943,11.494611310718946,12.379474189365235,3 +low-outdegree,100,simulation/10000,13.81282703357203,13.728049180609602,13.883727928501028,3 +low-outdegree,100,simulation/100000,13.875383314998306,13.734862792743394,14.083296475998885,3 +low-outdegree,100,stationary,2.746435984523101,2.7346458509489997,2.767940312333191,3 +low-outdegree,100,structure/classes-cold,10.137171888076152,9.938926223745613,10.507476574529786,3 +low-outdegree,100,structure/classes-lifecycle,15.16206112292087,14.945512977363055,15.188868909928313,3 +low-outdegree,100,structure/classes-warm/access,25.122622460532963,24.928298721193972,25.403253426554805,3 +low-outdegree,100,structure/classes-warm/consumed,11.466274059785428,11.107372391044002,11.5088590207907,3 +low-outdegree,100,structure/irreducible-cold,21.686942396699163,21.611113336158947,21.921672004488553,3 +low-outdegree,100,structure/irreducible-warm,23.460750422262475,23.27606008022043,23.545664557248013,3 +low-outdegree,100,visits/bounded-expectation/k-10,6.231200028668649,6.1860613713668435,6.256910276932357,3 +low-outdegree,100,visits/bounded-expectation/k-100,1.7917684845100048,1.790285291524837,1.7942060669286326,3 +low-outdegree,250,construction/public-consumed,10.490802296603235,10.455368209974793,10.582055056634086,3 +low-outdegree,250,evolution/k-10,4.349168999275953,4.342289169726232,4.357892548596855,3 +low-outdegree,250,evolution/k-100,1.6778788247659162,1.667487276559086,1.6796346757365663,3 +low-outdegree,250,evolution/one-step,26.248827299000016,26.19491466502612,26.33542591220045,3 +low-outdegree,250,hitting-probability/cold-all-states,5.990103791090945,5.96265308600829,6.001438666802655,3 +low-outdegree,250,hitting-time/cold-all-states,11.86087431216959,11.813901078489007,11.906425595083302,3 +low-outdegree,250,power/10,25.237236207389405,25.132263576172402,25.48841402541164,3 +low-outdegree,250,power/100,18.546494210083925,18.31149677127459,18.797192489481702,3 +low-outdegree,250,power/2,7.9479284759584266,7.878088888216936,8.00610727099782,3 +low-outdegree,250,race/forward-committor,15.946701107417548,15.73103335606123,16.028943837236206,3 +low-outdegree,250,return/mean-recurrence,4.126899857315318,4.117076672071023,4.204148476571489,3 +low-outdegree,250,simulation/10000,15.536923545483686,15.331313916195176,15.544703136485698,3 +low-outdegree,250,simulation/100000,15.772931568780965,15.692094984054668,15.78305922352922,3 +low-outdegree,250,stationary,1.1924105092190016,1.1920752462943485,1.2041684137646034,3 +low-outdegree,250,structure/classes-cold,11.224131967896735,10.834645058661506,11.227761697160789,3 +low-outdegree,250,structure/classes-lifecycle,10.385031160371836,10.384684890905978,10.509236412931882,3 +low-outdegree,250,structure/classes-warm/access,25.214137899236093,25.169947012871543,25.237182752616917,3 +low-outdegree,250,structure/classes-warm/consumed,10.733176106619243,10.658455838514023,10.807842669239722,3 +low-outdegree,250,structure/irreducible-cold,25.202396504470872,24.992184427035475,25.468742466676918,3 +low-outdegree,250,structure/irreducible-warm,23.313855356933853,23.192802727645677,23.425048975725424,3 +low-outdegree,500,construction/public-consumed,7.703590028828563,7.700512471659257,7.754539750553886,3 +low-outdegree,500,evolution/k-10,3.2987045732977585,3.2685018238267687,3.314922962142458,3 +low-outdegree,500,evolution/k-100,1.382874584304017,1.3798620239298023,1.3842281674877939,3 +low-outdegree,500,evolution/one-step,21.115204801574503,20.75281072043099,21.19219540010566,3 +low-outdegree,500,hitting-probability/cold-all-states,6.3946956461468405,6.37566273088135,6.446331012883586,3 +low-outdegree,500,hitting-time/cold-all-states,12.469339571289,12.465341581030177,12.474496585851618,3 +low-outdegree,500,power/10,18.108332302366257,17.896107913763196,18.14639808906358,3 +low-outdegree,500,power/100,11.224878340754728,11.201913200664304,11.235588739753116,3 +low-outdegree,500,power/2,5.727216669966606,5.70976431346736,5.743052416907981,3 +low-outdegree,500,race/forward-committor,10.597492298859189,10.595994906051807,10.655453348795591,3 +low-outdegree,500,return/mean-recurrence,2.371696290380643,2.275422166754319,2.3723971880776764,3 +low-outdegree,500,simulation/10000,16.47140171247755,16.310870121981015,16.66868177687591,3 +low-outdegree,500,simulation/100000,18.745253976176276,18.58807544170654,18.857122667275934,3 +low-outdegree,500,stationary,0.9337896209780348,0.9334024712012577,0.9387781481644061,3 +low-outdegree,500,structure/classes-cold,13.311248500453335,12.884100586559756,13.465546573576876,3 +low-outdegree,500,structure/classes-lifecycle,7.606894507891868,7.597671324865271,7.654391892165311,3 +low-outdegree,500,structure/classes-warm/access,24.77218955393308,24.605955820842347,24.904175916199517,3 +low-outdegree,500,structure/classes-warm/consumed,11.217800972358129,11.191926523630771,11.220793710080276,3 +low-outdegree,500,structure/irreducible-cold,28.582273937845283,28.522999378539126,28.697517159510515,3 +low-outdegree,500,structure/irreducible-warm,23.17534130101916,22.764566100692562,23.26017926344601,3 +low-outdegree,1000,construction/public-consumed,6.789792780795603,6.777920143930914,6.866540744518417,3 +low-outdegree,1000,evolution/k-10,1.9110760159979148,1.7443497672611785,2.2956430685295417,3 +low-outdegree,1000,evolution/k-100,0.968424034337219,0.9237807872703077,1.0835059376723162,3 +low-outdegree,1000,evolution/one-step,8.248994105173214,8.207623268552606,11.56622432405442,3 +low-outdegree,1000,simulation/10000,15.635223691422278,15.59400509847432,16.061212669575458,3 +low-outdegree,1000,simulation/100000,24.205641656308234,23.978461875685493,24.223313650431564,3 +low-outdegree,1000,structure/classes-cold,18.78864418123671,18.515050618952472,19.18366125751877,3 +low-outdegree,1000,structure/classes-lifecycle,6.843083378867198,6.826547590268327,6.8917360200386115,3 +low-outdegree,1000,structure/classes-warm/access,25.453504393292327,23.05499937262546,25.53126733125028,3 +low-outdegree,1000,structure/classes-warm/consumed,11.445373359789405,11.418434676933396,11.472498654679542,3 +low-outdegree,1000,structure/irreducible-cold,41.698330237752195,41.60126961255533,42.36814616245963,3 +low-outdegree,1000,structure/irreducible-warm,23.188976078774242,23.08400489087116,23.466863250858854,3 +periodic,10,construction/public-consumed,54.66446149349569,54.64709101596794,55.446233096968754,3 +periodic,10,evolution/k-10,31.10016095666058,30.94888187333613,31.624554463886128,3 +periodic,10,evolution/k-100,85.22708398237398,84.75826679362012,85.74976177792776,3 +periodic,10,evolution/one-step,120.34877973319833,119.77903859300493,120.89864044441347,3 +periodic,10,finite-time/n-step/k-10,15.559410624460156,15.460857243934514,15.561739118244128,3 +periodic,10,finite-time/n-step/k-100,13.154749946117699,13.146267847194697,13.265082801613023,3 +periodic,10,finite-time/observation/k-10,1.7886743407195107,1.788203910172341,1.8092207264656628,3 +periodic,10,finite-time/observation/k-100,1.0178481232848555,0.98369086540849,1.0330499648506535,3 +periodic,10,finite-time/step,1.1578735714901742,1.0900219727826688,1.220767513819942,3 +periodic,10,hitting-probability/cold-all-states,2.7682351273509176,2.7126961181254283,2.9199502186256954,3 +periodic,10,hitting-time/cold-all-states,6.4064907643003455,5.827385599378359,6.4492667977436895,3 +periodic,10,hitting/bounded/at-most/k-10,16.83133695941931,16.708918441135737,17.03040889794558,3 +periodic,10,hitting/bounded/at-most/k-100,130.63856472577191,128.20330041397364,132.57188669250465,3 +periodic,10,hitting/bounded/exact/k-10,17.04459529215396,16.771037249950847,17.059341252516568,3 +periodic,10,hitting/bounded/exact/k-100,136.0423081230068,135.09177750246118,138.07866552138353,3 +periodic,10,hitting/bounded/greater-than/k-10,17.864066620816075,17.535116882768474,18.099426389496884,3 +periodic,10,hitting/bounded/greater-than/k-100,137.4987744971928,134.41140593655962,138.32297740636133,3 +periodic,10,power/10,65.25629933476618,65.04297907827451,65.70282540281627,3 +periodic,10,power/100,51.15341429530325,51.03336070202528,51.27880140438829,3 +periodic,10,power/2,85.60431868643535,84.97058125914185,85.63134724291429,3 +periodic,10,return/bounded/k-10,12.582252541104717,12.57674492387628,12.611123817072874,3 +periodic,10,return/bounded/k-100,97.3214448488843,96.56394841269399,97.9558914116979,3 +periodic,10,stationary,12.39118542302161,12.11785498243772,12.475210806703187,3 +periodic,10,structure/classes-cold,7.263156087451713,7.212736945832682,7.525558258379192,3 +periodic,10,structure/classes-lifecycle,51.486129519226964,51.29165423318535,52.13991323485442,3 +periodic,10,structure/classes-warm/access,24.932764319048395,24.92127029278919,25.362276722838835,3 +periodic,10,structure/classes-warm/consumed,22.899158924281473,22.81585861928473,22.923125313830745,3 +periodic,10,structure/cyclic-classes-cold,61.64053452765247,60.57664326994148,63.22573736407293,3 +periodic,10,structure/cyclic-classes-warm,1.2432737536356775,1.2421582528003883,1.2460322056031743,3 +periodic,10,structure/irreducible-cold,10.7701656064038,10.551446271591447,11.082077953562042,3 +periodic,10,structure/irreducible-warm,23.194130737717,23.13570022107864,23.338430193232536,3 +periodic,10,structure/period-cold,43.70957341250405,43.42360187097344,43.87501548474328,3 +periodic,10,structure/period-warm,19.30430309181805,19.149600517743153,19.330526944538008,3 +periodic,10,visits/bounded-expectation/k-10,6.975896490522845,6.838369970568266,6.990362218601079,3 +periodic,10,visits/bounded-expectation/k-100,4.530835540774664,4.470938771015665,4.557014579531246,3 +periodic,25,construction/public-consumed,22.27504625210456,22.16852959890955,25.658727294305383,3 +periodic,25,evolution/k-10,27.864081056703625,27.833837807201792,29.871832500936286,3 +periodic,25,evolution/k-100,32.651275342808106,31.97734208160317,33.339731520799695,3 +periodic,25,evolution/one-step,109.70855134672469,107.48327830856937,111.30307451570197,3 +periodic,25,finite-time/n-step/k-10,14.71346440649847,14.565826339368362,14.747041355362068,3 +periodic,25,finite-time/n-step/k-100,9.457298840595993,9.319892404378995,9.52770308208095,3 +periodic,25,finite-time/observation/k-10,0.6012202434615307,0.5925635441408487,0.6267241155715333,3 +periodic,25,finite-time/observation/k-100,0.2750801651766794,0.26726269218599213,0.27653151916308355,3 +periodic,25,finite-time/step,1.5878942210660083,1.4629678426655255,1.601815706410365,3 +periodic,25,hitting-probability/cold-all-states,1.847648897034529,1.7858212384996854,1.8875310141091346,3 +periodic,25,hitting-time/cold-all-states,4.068171052168515,4.067418115184078,4.2500492734600455,3 +periodic,25,hitting/bounded/at-most/k-10,12.205951171554712,11.858690294797736,12.497840560216423,3 +periodic,25,hitting/bounded/at-most/k-100,91.18980272861037,90.82062079085763,93.80409148197236,3 +periodic,25,hitting/bounded/exact/k-10,12.56816595155099,12.166084722794622,12.61140319915477,3 +periodic,25,hitting/bounded/exact/k-100,96.2916991065443,91.74131582205513,100.15024850399143,3 +periodic,25,hitting/bounded/greater-than/k-10,13.031182239446036,11.859479927853046,13.556865592056969,3 +periodic,25,hitting/bounded/greater-than/k-100,97.48538697777633,93.86694169509211,98.94154920947767,3 +periodic,25,power/10,22.269157075103895,20.918717375317375,23.661871397121562,3 +periodic,25,power/100,17.572186100239083,17.335412792878785,17.728720309926562,3 +periodic,25,power/2,25.90581947258338,25.42780203101099,26.595307273729524,3 +periodic,25,return/bounded/k-10,13.556370170961527,12.967048956375372,13.995303087198264,3 +periodic,25,return/bounded/k-100,55.323739573045096,55.15022828575491,56.814276655810964,3 +periodic,25,stationary,10.776968101614438,10.124466535786468,10.957357199033439,3 +periodic,25,structure/classes-cold,8.24043007615583,8.111237137586174,8.842104461749084,3 +periodic,25,structure/classes-lifecycle,22.174671049935704,22.108140279673776,23.050880927527565,3 +periodic,25,structure/classes-warm/access,25.992483833211228,25.43485417162516,27.67006970681481,3 +periodic,25,structure/classes-warm/consumed,16.256845059595296,16.160174057472435,16.5361282389558,3 +periodic,25,structure/cyclic-classes-cold,88.14040779654893,88.12468288451194,111.76676136071544,3 +periodic,25,structure/cyclic-classes-warm,1.0233788381021942,1.017711063811528,1.0889956723793186,3 +periodic,25,structure/irreducible-cold,13.97308994028259,13.836129935479835,14.466787527714143,3 +periodic,25,structure/irreducible-warm,23.245417781690197,23.113931516201077,24.02756990911624,3 +periodic,25,structure/period-cold,71.73107047081099,71.07176463888989,73.00004820547692,3 +periodic,25,structure/period-warm,19.28399539082752,18.992265390529816,19.30085147870817,3 +periodic,25,visits/bounded-expectation/k-10,7.916593185399225,7.821970077935815,7.921514988158538,3 +periodic,25,visits/bounded-expectation/k-100,3.282436346902015,3.273501191432157,3.4197052601587252,3 +periodic,50,construction/public-consumed,16.93795031478435,16.878903282960998,17.051856469223928,3 +periodic,50,evolution/k-10,19.77153282039884,18.342889621445806,19.90081445042257,3 +periodic,50,evolution/k-100,15.49450264289954,15.31977497327586,15.615972431202179,3 +periodic,50,evolution/one-step,84.46529204713218,84.0075920355936,84.82845451709532,3 +periodic,50,finite-time/n-step/k-10,14.59775216134237,14.578251003971678,14.675580779348357,3 +periodic,50,finite-time/n-step/k-100,7.389970332445747,7.3659134818397485,7.393916808288508,3 +periodic,50,finite-time/observation/k-10,0.2859226110583617,0.2821891620870332,0.2866808574342022,3 +periodic,50,finite-time/observation/k-100,0.10960787058561046,0.10850603981843075,0.11047807730119956,3 +periodic,50,finite-time/step,1.7562369151313524,1.7217236752687797,1.7638992842947543,3 +periodic,50,hitting-probability/cold-all-states,1.642583715261392,1.6390481517244162,1.6500452980683877,3 +periodic,50,hitting-time/cold-all-states,3.6250343671484235,3.621015033494674,3.6601906834274796,3 +periodic,50,hitting/bounded/at-most/k-10,13.56445640184763,12.834289927457267,13.590022650997225,3 +periodic,50,hitting/bounded/at-most/k-100,58.61303176476207,58.01270921461893,58.737390920643136,3 +periodic,50,hitting/bounded/exact/k-10,13.506617545584579,13.371298108077943,13.60246843746856,3 +periodic,50,hitting/bounded/exact/k-100,59.23636425800852,58.50668779134835,59.69380786161533,3 +periodic,50,hitting/bounded/greater-than/k-10,13.746739783782012,13.576091052098775,13.824384256179302,3 +periodic,50,hitting/bounded/greater-than/k-100,59.409452646608,58.94501211780498,59.429007634428956,3 +periodic,50,power/10,10.733674082778476,10.680475461594368,11.295555011710329,3 +periodic,50,power/100,9.00954019483761,8.947253585531255,9.027907037901347,3 +periodic,50,power/2,12.297125815171002,12.214582842430655,12.820075189369271,3 +periodic,50,return/bounded/k-10,14.048635889245766,13.918780161889718,14.22394946760638,3 +periodic,50,return/bounded/k-100,32.41342631449878,32.30173995764741,32.53794333357247,3 +periodic,50,stationary,6.292193326622928,6.228483366061593,6.307121599905645,3 +periodic,50,structure/classes-cold,9.531766270101755,9.34592299542508,9.704507240083494,3 +periodic,50,structure/classes-lifecycle,17.058614295855012,16.86479777685685,17.838079390654705,3 +periodic,50,structure/classes-warm/access,25.15814109015651,25.014717897596285,25.311992584378874,3 +periodic,50,structure/classes-warm/consumed,12.824418963831285,12.816631933668123,12.851602970280792,3 +periodic,50,structure/cyclic-classes-cold,124.24358644189613,122.81323974493627,124.42710295101239,3 +periodic,50,structure/cyclic-classes-warm,0.9485422966401185,0.9440676779608378,0.9515684042023042,3 +periodic,50,structure/irreducible-cold,17.58123237980971,17.45915425867367,17.60934093747317,3 +periodic,50,structure/irreducible-warm,23.06510687804481,22.781877946807356,23.271129056366853,3 +periodic,50,structure/period-cold,111.41750529701035,109.52350264747217,112.00285088063485,3 +periodic,50,structure/period-warm,19.37339282728051,19.216553599380056,19.732393891427723,3 +periodic,50,visits/bounded-expectation/k-10,9.940034998327128,9.858165415775366,9.954629436405797,3 +periodic,50,visits/bounded-expectation/k-100,3.1629568778603607,3.158940330533494,3.1954008799493394,3 +periodic,100,construction/public-consumed,15.276784170498814,15.245425120903677,15.412931272271988,3 +periodic,100,evolution/k-10,13.442922554671213,13.410749437591306,13.472820057739938,3 +periodic,100,evolution/k-100,4.57359816394583,4.568872100874481,4.6055643674940105,3 +periodic,100,evolution/one-step,67.69214913917298,65.75943729366762,74.82752128057336,3 +periodic,100,finite-time/n-step/k-10,15.120602393504614,14.966169696891638,15.127752164949593,3 +periodic,100,finite-time/n-step/k-100,6.183202890292509,6.170019458523325,6.2564851248664475,3 +periodic,100,finite-time/observation/k-10,0.13773469397068216,0.13712332938722996,0.17473555840866933,3 +periodic,100,finite-time/observation/k-100,0.04891968123591132,0.048765099337223936,0.0490448486227719,3 +periodic,100,finite-time/step,3.0359774978653506,2.943423021679245,3.1511312541107195,3 +periodic,100,hitting-probability/cold-all-states,2.1355893102510315,2.12667672876421,2.2164322095711464,3 +periodic,100,hitting-time/cold-all-states,4.604903758856842,4.60455575683669,4.611558796459323,3 +periodic,100,hitting/bounded/at-most/k-10,18.35713754675296,18.18212231020573,18.440762260580552,3 +periodic,100,hitting/bounded/at-most/k-100,43.44060808171705,43.142336645046456,47.764493294634136,3 +periodic,100,hitting/bounded/exact/k-10,18.319395334813475,18.137577592095006,18.38906574146267,3 +periodic,100,hitting/bounded/exact/k-100,43.36917939582149,42.67150016593965,43.50225787583511,3 +periodic,100,hitting/bounded/greater-than/k-10,18.58965553733426,16.77517039441448,18.5910163057071,3 +periodic,100,hitting/bounded/greater-than/k-100,43.5904560024394,43.45476977875457,44.28173792406861,3 +periodic,100,power/10,6.735414501906548,6.436965624487024,7.172873563339899,3 +periodic,100,power/100,5.51802195441269,5.164465245736242,5.695483384873723,3 +periodic,100,power/2,8.149432622167216,7.939159360946717,8.208333631215506,3 +periodic,100,return/bounded/k-10,19.1239426802577,19.108279366375392,19.20766121827217,3 +periodic,100,return/bounded/k-100,23.40841923391999,23.164564819285843,23.687598209347918,3 +periodic,100,stationary,2.685293633090947,2.6800510292256488,2.7150018654702164,3 +periodic,100,structure/classes-cold,11.830437623134403,11.703044313667322,11.839557605967338,3 +periodic,100,structure/classes-lifecycle,15.32173181242751,15.297884909231348,15.848751368512472,3 +periodic,100,structure/classes-warm/access,25.191131900435213,24.939276261934236,25.440638197564294,3 +periodic,100,structure/classes-warm/consumed,11.56187312379149,11.39375996942997,12.138165605926655,3 +periodic,100,structure/cyclic-classes-cold,183.71086365871489,183.5452982601209,188.96749570273343,3 +periodic,100,structure/cyclic-classes-warm,0.9138554526118922,0.9096206898933655,0.9152900947279881,3 +periodic,100,structure/irreducible-cold,23.579108838792738,23.13260278873405,23.850509577154057,3 +periodic,100,structure/irreducible-warm,23.436638261418278,22.95650961123424,24.69341322001739,3 +periodic,100,structure/period-cold,189.4139593314381,187.78252190042957,191.88885832927417,3 +periodic,100,structure/period-warm,19.138337257580172,18.921654349501974,19.640984301500485,3 +periodic,100,visits/bounded-expectation/k-10,12.572742042120453,11.747825970739706,14.859110818075456,3 +periodic,100,visits/bounded-expectation/k-100,3.291334026956079,3.2896408451303945,3.7133281611626123,3 +periodic,250,construction/public-consumed,10.437585894155687,10.021930081134387,10.467053133048923,3 +periodic,250,evolution/k-10,4.40670438052328,4.388436060616922,4.724453088984914,3 +periodic,250,evolution/k-100,1.6759066707735661,1.6756733188571251,1.7108288230658732,3 +periodic,250,evolution/one-step,26.915301595932018,26.704087683608012,29.310482606498642,3 +periodic,250,hitting-probability/cold-all-states,4.432450285502626,4.407950366141147,4.435554074484146,3 +periodic,250,hitting-time/cold-all-states,9.376415896853109,9.2962285029622,9.441936180482806,3 +periodic,250,power/10,4.863923399250012,4.7884266425051765,4.880726816586078,3 +periodic,250,power/100,3.739272592534655,3.724212633672454,4.098377105134121,3 +periodic,250,power/2,6.356526537885548,6.352225665035911,6.435908909769285,3 +periodic,250,stationary,1.169486799194331,1.1694714664398436,1.184485952520946,3 +periodic,250,structure/classes-cold,15.321475289050833,15.117209689096875,15.599446087737489,3 +periodic,250,structure/classes-lifecycle,10.372468598826382,10.293679406559296,10.452310894493314,3 +periodic,250,structure/classes-warm/access,24.66997031901153,24.572007279734557,25.126317002648616,3 +periodic,250,structure/classes-warm/consumed,10.778818625319897,10.763386269619595,10.80434160706453,3 +periodic,250,structure/cyclic-classes-cold,277.58149866115366,272.4944331737509,285.7747511629344,3 +periodic,250,structure/cyclic-classes-warm,0.8901041486409926,0.8874434667263547,0.8945670637126352,3 +periodic,250,structure/irreducible-cold,30.21258599797582,29.529368521023358,36.226519276175566,3 +periodic,250,structure/irreducible-warm,23.10452757607473,21.975490232856682,23.148375043396296,3 +periodic,250,structure/period-cold,305.61335931357155,302.656076886994,310.7415217230571,3 +periodic,250,structure/period-warm,19.226496038826802,19.04993407996588,19.607783837995076,3 +periodic,500,construction/public-consumed,7.525023952271946,7.3710977664629596,7.701723192950403,3 +periodic,500,evolution/k-10,3.4355693648323147,3.2397340335593383,3.4740364242510076,3 +periodic,500,evolution/k-100,1.3998225445493906,1.370633907718095,1.4349783303857155,3 +periodic,500,evolution/one-step,21.30508541580444,21.009097882354595,22.786098166828822,3 +periodic,500,hitting-probability/cold-all-states,4.409802145335504,4.352480447544975,4.614464998573955,3 +periodic,500,hitting-time/cold-all-states,9.51952634379551,9.291452001490669,9.854479047101632,3 +periodic,500,power/10,3.7101992476846597,3.680394992519896,3.7223290967567633,3 +periodic,500,power/100,2.497990191120638,2.492225688331176,2.533369388775687,3 +periodic,500,power/2,5.243668461737486,5.204500718198526,5.302867567500859,3 +periodic,500,stationary,0.9203435439510346,0.9137701760896946,0.9576292537786284,3 +periodic,500,structure/classes-cold,21.538352909335945,21.248500365772202,21.75504798515517,3 +periodic,500,structure/classes-lifecycle,7.625807736894597,7.551926658763413,7.674143992003148,3 +periodic,500,structure/classes-warm/access,24.69307232516706,23.49591525258463,25.01068449043572,3 +periodic,500,structure/classes-warm/consumed,11.34890374301104,11.267107058305035,11.378623368877404,3 +periodic,500,structure/cyclic-classes-cold,500.6991738174678,497.5753457996969,501.2406260178597,3 +periodic,500,structure/cyclic-classes-warm,0.926237941463265,0.9243734823918037,0.9275683225652424,3 +periodic,500,structure/irreducible-cold,41.06692272602524,38.704361453956494,41.839575413595654,3 +periodic,500,structure/irreducible-warm,22.7891040464629,22.436825724800748,23.41793294268849,3 +periodic,500,structure/period-cold,518.1037655969324,511.24855017749815,521.04315991682,3 +periodic,500,structure/period-warm,19.343500243944245,18.97603850629958,19.630724224996545,3 +periodic,1000,construction/public-consumed,6.8188402602805365,6.769079930139256,6.820592117486039,3 +periodic,1000,evolution/k-10,2.0864317161362984,2.0258393625473876,2.23757626296933,3 +periodic,1000,evolution/k-100,1.0944008541335977,1.0631517807174997,1.1380564318809856,3 +periodic,1000,evolution/one-step,10.959766707014062,10.84548836020236,11.325773711563743,3 +periodic,1000,structure/classes-cold,36.12061304595555,35.97493473729636,36.5032472119531,3 +periodic,1000,structure/classes-lifecycle,6.714430621558222,6.645012013297067,6.719023259980693,3 +periodic,1000,structure/classes-warm/access,25.159019666429074,24.971017762417375,25.271710614796433,3 +periodic,1000,structure/classes-warm/consumed,11.62203130323196,11.617679949433397,11.684749885510975,3 +periodic,1000,structure/cyclic-classes-cold,967.2263587390518,965.6649447034632,969.9014282954292,3 +periodic,1000,structure/cyclic-classes-warm,0.9389103546254827,0.9374097785785652,0.9398638173541393,3 +periodic,1000,structure/irreducible-cold,69.4281231420447,68.95315949174227,69.58734962368895,3 +periodic,1000,structure/irreducible-warm,22.9501914102406,22.92404853923551,23.091538926459876,3 +periodic,1000,structure/period-cold,1013.1901287930456,1012.1783353026401,1017.8616271729484,3 +periodic,1000,structure/period-warm,19.378418035206167,19.337214879930695,19.603803323389535,3 +reducible,10,construction/public-consumed,57.31435682088167,57.071395756826846,57.4522499923017,3 +reducible,10,evolution/k-10,31.54703903116071,31.33913157077594,31.914230745609558,3 +reducible,10,evolution/k-100,84.88033562252997,84.37882523230671,85.07415134392352,3 +reducible,10,evolution/one-step,121.89848201473531,121.64144206321554,123.15822426676014,3 +reducible,10,finite-time/n-step/k-10,17.329940896803535,16.9172654539259,17.707300462205804,3 +reducible,10,finite-time/n-step/k-100,14.988445700336328,14.847081587174197,15.062018200287678,3 +reducible,10,finite-time/observation/k-10,14.951865205158116,14.714166378208118,15.31190112672478,3 +reducible,10,finite-time/observation/k-100,14.338310299593516,14.246634272837799,14.475489519086006,3 +reducible,10,finite-time/step,1.1539058518212897,1.1293063834072201,1.158560034901611,3 +reducible,10,hitting-probability/cold-all-states,2.9829173349003493,2.9401276703091725,2.984022837430583,3 +reducible,10,hitting-time/cold-all-states,16.31558109838882,16.07436472366647,16.419689164739303,3 +reducible,10,hitting/bounded/at-most/k-10,13.35051138872153,13.025728837875244,13.419947719672866,3 +reducible,10,hitting/bounded/at-most/k-100,18.025597362113828,17.817467922760724,18.038804208362272,3 +reducible,10,hitting/bounded/exact/k-10,13.002200403127075,12.992941193203054,13.169268515099036,3 +reducible,10,hitting/bounded/exact/k-100,18.186504590415062,18.136931924928746,18.356850933983985,3 +reducible,10,hitting/bounded/greater-than/k-10,13.453891822261916,13.453547786391535,13.463136451488948,3 +reducible,10,hitting/bounded/greater-than/k-100,18.044895538736608,17.910541116769238,18.535185330090307,3 +reducible,10,occupation-matrix,28.563901859542195,28.492146543045283,28.624233519636274,3 +reducible,10,power/10,70.03445317157728,69.42570409253402,70.368517580796,3 +reducible,10,power/100,54.4917328640181,54.46515904622537,56.59566920786062,3 +reducible,10,power/2,90.82994980051836,90.27745148298409,91.45220674339774,3 +reducible,10,return/bounded/k-10,14.610591869489815,14.473849867428614,14.835492485148105,3 +reducible,10,return/bounded/k-100,18.37056942140311,18.296873771936763,18.94219404923155,3 +reducible,10,stationary,15.047305231097665,14.92711672423652,15.535597631922718,3 +reducible,10,structure/classes-cold,8.213893347013029,7.998095397562365,8.247227937874376,3 +reducible,10,structure/classes-lifecycle,49.81682097505722,48.42248051632651,49.86830774177793,3 +reducible,10,structure/classes-warm/access,25.36420575222952,23.375511303695713,25.603563388138078,3 +reducible,10,structure/classes-warm/consumed,22.723389093559582,22.574683847027064,22.855777423477946,3 +reducible,10,structure/irreducible-cold,11.779514660576615,11.4949738891004,11.827688064479418,3 +reducible,10,structure/irreducible-warm,23.83346982694304,23.740406146321607,25.155848712891572,3 +reducible,10,visits/bounded-expectation/k-10,3.871449263199117,3.8397869759431575,3.8772889653960774,3 +reducible,10,visits/bounded-expectation/k-100,2.125773776013471,2.1121657928465924,2.144018109493355,3 +reducible,25,construction/public-consumed,26.357176691098218,26.345184296705202,26.38100785760586,3 +reducible,25,evolution/k-10,27.891657759051594,27.80314109182467,28.03184848663048,3 +reducible,25,evolution/k-100,32.48754358417514,32.348502106939314,32.72838117710219,3 +reducible,25,evolution/one-step,108.3667423501173,107.08104766805118,111.49671024667472,3 +reducible,25,finite-time/n-step/k-10,17.119144010951235,16.563856974713936,17.153045743368526,3 +reducible,25,finite-time/n-step/k-100,11.45627444129713,11.417011115038454,11.482876501844947,3 +reducible,25,finite-time/observation/k-10,14.109618448827007,14.011162880110634,14.28253007220505,3 +reducible,25,finite-time/observation/k-100,11.21382368375022,11.177682941229223,11.268100553221492,3 +reducible,25,finite-time/step,1.5632248586173647,1.5493211961143787,1.5749144512743452,3 +reducible,25,hitting-probability/cold-all-states,1.697280392512117,1.6796685766869714,1.74740576556614,3 +reducible,25,hitting-time/cold-all-states,6.099430975933869,6.097691142837171,6.287736867654803,3 +reducible,25,hitting/bounded/at-most/k-10,14.247125573387708,13.859923300557588,14.620463724835158,3 +reducible,25,hitting/bounded/at-most/k-100,20.97686306678311,20.06282529436679,22.129965629229936,3 +reducible,25,hitting/bounded/exact/k-10,14.04998534636816,13.962389616171214,14.598680458591447,3 +reducible,25,hitting/bounded/exact/k-100,20.825935857223453,20.209469376944284,20.970040233186378,3 +reducible,25,hitting/bounded/greater-than/k-10,14.282647705284447,14.018607872487824,14.356803946394342,3 +reducible,25,hitting/bounded/greater-than/k-100,20.290589543019777,20.109939286646824,21.484576990542372,3 +reducible,25,occupation-matrix,28.47087518610547,28.18553987741487,28.53719397763619,3 +reducible,25,power/10,31.747071411223416,31.498132965112703,36.24348440684096,3 +reducible,25,power/100,26.363601044759626,25.889296754707374,27.118893109421723,3 +reducible,25,power/2,39.43673598192472,38.54197543359135,40.550772886422756,3 +reducible,25,return/bounded/k-10,16.321191006704794,15.751131454150258,16.561798922753432,3 +reducible,25,return/bounded/k-100,20.40242472683203,20.352065367370987,22.183974175787423,3 +reducible,25,stationary,20.913400603880188,20.830408508608496,20.94437144779975,3 +reducible,25,structure/classes-cold,12.059964835325342,11.72242729197371,13.169210164323154,3 +reducible,25,structure/classes-lifecycle,23.417850183842376,23.1155764935474,23.6085304830412,3 +reducible,25,structure/classes-warm/access,25.415136048438576,25.11609032948314,25.808685083366434,3 +reducible,25,structure/classes-warm/consumed,15.852846079492123,15.802828816938852,15.918475507628163,3 +reducible,25,structure/irreducible-cold,15.339271247807385,14.824081812073626,15.915893228351107,3 +reducible,25,structure/irreducible-warm,23.79558509962253,23.738520281726657,23.855589871107163,3 +reducible,25,visits/bounded-expectation/k-10,5.009113843514018,4.886918478901888,5.227023610326794,3 +reducible,25,visits/bounded-expectation/k-100,2.1947018358345094,2.1912654521890502,2.2342039991460156,3 +reducible,50,construction/public-consumed,20.82726275247997,20.29884748305302,20.920208403026663,3 +reducible,50,evolution/k-10,20.030135493000348,19.36954447244667,20.15305455932836,3 +reducible,50,evolution/k-100,15.489005799822555,15.381582773481723,15.50873032273386,3 +reducible,50,evolution/one-step,84.67560921112383,82.4605920663524,92.43873531763603,3 +reducible,50,finite-time/n-step/k-10,14.866914114478748,14.838720263410664,15.262037175529963,3 +reducible,50,finite-time/n-step/k-100,7.314601629495305,7.269914329631151,7.343496126220264,3 +reducible,50,finite-time/observation/k-10,12.002983788561371,11.893808427879998,12.084917703980285,3 +reducible,50,finite-time/observation/k-100,7.149161907646442,7.09839018455373,7.18901514293235,3 +reducible,50,finite-time/step,1.9357053016338006,1.9267490521083674,2.1841724937026252,3 +reducible,50,hitting-probability/cold-all-states,1.4967795034404752,1.4767336395898578,1.7664910600181025,3 +reducible,50,hitting-time/cold-all-states,3.802021711322215,3.7874431709623635,3.857587604492423,3 +reducible,50,hitting/bounded/at-most/k-10,11.887658175375599,11.742427960599372,20.629474806128453,3 +reducible,50,hitting/bounded/at-most/k-100,17.05236057487154,17.020045254504954,17.086826250835195,3 +reducible,50,hitting/bounded/exact/k-10,11.65473013565086,11.629871120916611,11.657449279071031,3 +reducible,50,hitting/bounded/exact/k-100,17.062143144763144,17.03348325796674,17.18113149832192,3 +reducible,50,hitting/bounded/greater-than/k-10,11.747156076318408,11.554702747489738,11.769474466862226,3 +reducible,50,hitting/bounded/greater-than/k-100,17.06999928796173,16.997600183446,17.092856838389114,3 +reducible,50,occupation-matrix,34.23901995286661,33.93535541733749,35.9809842788031,3 +reducible,50,power/10,26.45253352379304,25.865331575004063,26.504157748415974,3 +reducible,50,power/100,22.077410984723546,21.522648525065293,22.280882455898343,3 +reducible,50,power/2,27.875454246679936,27.515053197408818,29.475809750469658,3 +reducible,50,return/bounded/k-10,14.729431201105866,14.080488164937055,14.8704891423317,3 +reducible,50,return/bounded/k-100,17.58569400050675,17.5771103927894,18.799856379755404,3 +reducible,50,stationary,23.16725431971863,23.0337607195079,24.041890711172275,3 +reducible,50,structure/classes-cold,12.826102901561802,12.354136897766391,13.037261520019449,3 +reducible,50,structure/classes-lifecycle,18.311176511516663,18.17080041212987,18.51824173116355,3 +reducible,50,structure/classes-warm/access,24.561991827776612,24.00745254281556,25.22002314631249,3 +reducible,50,structure/classes-warm/consumed,12.977414288220814,12.702699361089053,12.98001507567072,3 +reducible,50,structure/irreducible-cold,15.30089752646157,14.879288130513388,15.520755314731609,3 +reducible,50,structure/irreducible-warm,23.502866085023115,21.832546024426687,24.226964549666256,3 +reducible,50,visits/bounded-expectation/k-10,6.226586655305317,6.217226284780255,6.276987409901662,3 +reducible,50,visits/bounded-expectation/k-100,2.0707712194654224,2.0013305532055257,2.153320936430698,3 +reducible,100,construction/public-consumed,19.381552124886216,19.106166746402817,19.628251198412354,3 +reducible,100,evolution/k-10,13.779391439708153,13.639686061077766,15.708754870832202,3 +reducible,100,evolution/k-100,4.638883403351589,4.594203115141249,4.660119713801407,3 +reducible,100,evolution/one-step,67.98227201706514,66.86911470013567,77.84749882320605,3 +reducible,100,finite-time/n-step/k-10,11.450984303259395,11.278915956700343,12.611247316020437,3 +reducible,100,finite-time/n-step/k-100,4.5481767341222685,4.523724797265196,5.121241528877919,3 +reducible,100,finite-time/observation/k-10,11.262310351070925,9.55106190248719,13.536804047032954,3 +reducible,100,finite-time/observation/k-100,4.373487274589755,4.3487825777891285,4.685250991399412,3 +reducible,100,finite-time/step,3.4287946053254648,2.524223131409796,6.873327619624457,3 +reducible,100,hitting-probability/cold-all-states,1.8941235735796267,1.8304870371052788,2.096340780434679,3 +reducible,100,hitting-time/cold-all-states,3.5601029061707035,3.5390372318605205,3.884197913839694,3 +reducible,100,hitting/bounded/at-most/k-10,9.605715995999567,9.491421789951778,10.062526126176705,3 +reducible,100,hitting/bounded/at-most/k-100,15.934529564014818,15.816495546563203,16.194573397549938,3 +reducible,100,hitting/bounded/exact/k-10,9.699932639253094,9.687631735433445,11.331489858461522,3 +reducible,100,hitting/bounded/exact/k-100,16.074404558324243,16.07381646525996,16.73579630535169,3 +reducible,100,hitting/bounded/greater-than/k-10,9.6422484104744,8.992432438801712,11.026650758621852,3 +reducible,100,hitting/bounded/greater-than/k-100,16.013248860483085,15.777525294144246,16.05844478271325,3 +reducible,100,occupation-matrix,31.48344156831675,30.437584659271486,31.49516306170555,3 +reducible,100,power/10,24.953281681903718,24.511536454129885,25.777010432675258,3 +reducible,100,power/100,19.992281019450914,19.019767190909366,20.739364875762377,3 +reducible,100,power/2,26.41987247808198,26.247435578115585,27.047772028810684,3 +reducible,100,return/bounded/k-10,14.12431813488494,13.983633362865309,17.324068213811334,3 +reducible,100,return/bounded/k-100,16.835671058163303,16.76853477779501,16.83618717413807,3 +reducible,100,stationary,24.25105246076073,23.602295238089926,24.587559050851382,3 +reducible,100,structure/classes-cold,13.172085015848191,13.154220191770126,13.725938419601029,3 +reducible,100,structure/classes-lifecycle,16.133432619832647,15.643214501142161,16.384589289615874,3 +reducible,100,structure/classes-warm/access,25.09263475247289,24.105136808188924,25.245203472175437,3 +reducible,100,structure/classes-warm/consumed,11.46126394900063,11.438240066393,11.556665168631666,3 +reducible,100,structure/irreducible-cold,14.795072809646388,14.392070825102955,15.08038555881801,3 +reducible,100,structure/irreducible-warm,23.90749140101455,23.67563893667323,25.938008496194104,3 +reducible,100,visits/bounded-expectation/k-10,6.3224881076540065,6.018439596175496,6.491637452517361,3 +reducible,100,visits/bounded-expectation/k-100,1.8276155957752203,1.8162050611522556,1.922378952364169,3 +reducible,250,construction/public-consumed,13.440836077125379,13.246987442709997,13.74259298479228,3 +reducible,250,evolution/k-10,5.038410540910749,4.981991676677521,5.150900511740963,3 +reducible,250,evolution/k-100,1.747997641404126,1.7437790003381604,1.7480465209839593,3 +reducible,250,evolution/one-step,31.79513042787878,31.59296300219302,32.86195958051851,3 +reducible,250,hitting-probability/cold-all-states,3.3296818137474737,3.3279488847289462,3.348540567812139,3 +reducible,250,hitting-time/cold-all-states,4.660237937613108,4.6233826236516755,4.672393436375036,3 +reducible,250,occupation-matrix,34.48297481422739,32.48165615405256,34.825077239810796,3 +reducible,250,power/10,19.61542531068868,18.045000002698245,19.66042556970387,3 +reducible,250,power/100,15.870212789796609,15.763678335503593,15.925858386561288,3 +reducible,250,power/2,25.57198156047058,25.537956815127856,25.581311380458306,3 +reducible,250,stationary,22.118030670401815,22.109331453631274,22.24052633187675,3 +reducible,250,structure/classes-cold,12.6312412432041,12.577133517127452,12.695654894160947,3 +reducible,250,structure/classes-lifecycle,10.673484965118693,10.608058139935263,10.775450691742968,3 +reducible,250,structure/classes-warm/access,25.112076018672386,23.273346279726127,25.426521886894587,3 +reducible,250,structure/classes-warm/consumed,10.796519094437194,10.717811020038482,10.835632248918573,3 +reducible,250,structure/irreducible-cold,12.995005457480257,12.916162199830387,13.037715613721025,3 +reducible,250,structure/irreducible-warm,23.43946065059647,23.395415933536086,23.539452090291316,3 +reducible,500,construction/public-consumed,10.000113024132133,9.848383966335492,10.049870138090665,3 +reducible,500,evolution/k-10,3.4418447289764385,3.3820043160861375,3.4548952712150003,3 +reducible,500,evolution/k-100,1.399572365785616,1.3983557384905259,1.4012982391578208,3 +reducible,500,evolution/one-step,21.925190524130972,21.72474801255448,22.01234844222421,3 +reducible,500,hitting-probability/cold-all-states,3.753334919264832,3.687348291629801,3.8822890031130726,3 +reducible,500,hitting-time/cold-all-states,5.361123953532604,5.257589200001232,5.411729091069608,3 +reducible,500,power/10,13.406505494658584,13.160688946702583,13.59162430348565,3 +reducible,500,power/100,9.602696675402854,9.563403034177048,9.613041372549699,3 +reducible,500,power/2,19.96685765116789,19.86014138451214,20.160287364110104,3 +reducible,500,stationary,18.714914769161194,18.6049523927407,18.997318719689495,3 +reducible,500,structure/classes-cold,10.65405615416232,10.466644869967219,10.770244323804949,3 +reducible,500,structure/classes-lifecycle,8.163676610477374,8.139277836537254,8.253883179736729,3 +reducible,500,structure/classes-warm/access,24.873805004594974,24.64314837570111,25.07920225798261,3 +reducible,500,structure/classes-warm/consumed,11.36480378416838,11.351246733369287,11.374177256777505,3 +reducible,500,structure/irreducible-cold,10.906249053038815,10.846067849561598,10.924206318707416,3 +reducible,500,structure/irreducible-warm,23.02981500438876,22.77973475165827,23.365344803336527,3 +reducible,1000,construction/public-consumed,8.925409172603157,8.8162932772307,9.029575207014526,3 +reducible,1000,evolution/k-10,1.8309296745883208,1.8135892520400727,1.8672945712283702,3 +reducible,1000,evolution/k-100,1.0590482114856477,1.0497962530255964,1.0638168348168835,3 +reducible,1000,evolution/one-step,9.521285495368177,9.403272459174374,9.56546152779292,3 +reducible,1000,structure/classes-cold,3.9871219599423755,3.8644079633483566,4.058687884542632,3 +reducible,1000,structure/classes-lifecycle,6.530642877748845,6.506691942526172,6.546840780218748,3 +reducible,1000,structure/classes-warm/access,25.103430488202427,25.082683289671888,25.273717724968364,3 +reducible,1000,structure/classes-warm/consumed,11.627063837438694,11.485707177372738,11.64173677501544,3 +reducible,1000,structure/irreducible-cold,4.180041596964045,4.134915523707161,4.1859207246114805,3 +reducible,1000,structure/irreducible-warm,23.600489900299664,23.28831082368587,23.602142676140183,3 diff --git a/benchmark/results/ratios.csv b/benchmark/results/ratios.csv new file mode 100644 --- /dev/null +++ b/benchmark/results/ratios.csv @@ -0,0 +1,2797 @@ +dataset,family,size,seed,operation,pydtmc_over_dtmc +absorbing-n0010-s01729,absorbing,10,1729,absorption-time,9.45558475240783 +absorbing-n0010-s01729,absorbing,10,1729,absorption/probabilities,9.42038873375433 +absorbing-n0010-s01729,absorbing,10,1729,construction/public-consumed,58.47297183810736 +absorbing-n0010-s01729,absorbing,10,1729,evolution/k-10,31.392611387358116 +absorbing-n0010-s01729,absorbing,10,1729,evolution/k-100,84.41113959175361 +absorbing-n0010-s01729,absorbing,10,1729,evolution/one-step,121.14601585774416 +absorbing-n0010-s01729,absorbing,10,1729,finite-time/n-step/k-10,16.960427866568512 +absorbing-n0010-s01729,absorbing,10,1729,finite-time/n-step/k-100,14.91672512616429 +absorbing-n0010-s01729,absorbing,10,1729,finite-time/observation/k-10,14.930784011106324 +absorbing-n0010-s01729,absorbing,10,1729,finite-time/observation/k-100,14.562716805870394 +absorbing-n0010-s01729,absorbing,10,1729,finite-time/step,1.1561888459873055 +absorbing-n0010-s01729,absorbing,10,1729,fundamental-matrix,7.755665271720604 +absorbing-n0010-s01729,absorbing,10,1729,hitting-probability/cold-all-states,2.661509405507161 +absorbing-n0010-s01729,absorbing,10,1729,hitting-time/cold-all-states,6.195325126923157 +absorbing-n0010-s01729,absorbing,10,1729,hitting/bounded/at-most/k-10,13.19613056121106 +absorbing-n0010-s01729,absorbing,10,1729,hitting/bounded/at-most/k-100,17.87981840076335 +absorbing-n0010-s01729,absorbing,10,1729,hitting/bounded/exact/k-10,12.868563912709723 +absorbing-n0010-s01729,absorbing,10,1729,hitting/bounded/exact/k-100,18.45238213406581 +absorbing-n0010-s01729,absorbing,10,1729,hitting/bounded/greater-than/k-10,13.676738300121352 +absorbing-n0010-s01729,absorbing,10,1729,hitting/bounded/greater-than/k-100,18.171290015447376 +absorbing-n0010-s01729,absorbing,10,1729,occupation-matrix,20.90160785592371 +absorbing-n0010-s01729,absorbing,10,1729,power/10,71.36010332259025 +absorbing-n0010-s01729,absorbing,10,1729,power/100,55.90959343988362 +absorbing-n0010-s01729,absorbing,10,1729,power/2,93.31775901401524 +absorbing-n0010-s01729,absorbing,10,1729,return/bounded/k-10,14.399008266080672 +absorbing-n0010-s01729,absorbing,10,1729,return/bounded/k-100,17.67810747758657 +absorbing-n0010-s01729,absorbing,10,1729,stationary,18.157236334023136 +absorbing-n0010-s01729,absorbing,10,1729,structure/classes-cold,8.394173657039387 +absorbing-n0010-s01729,absorbing,10,1729,structure/classes-lifecycle,50.3216288552908 +absorbing-n0010-s01729,absorbing,10,1729,structure/classes-warm/access,25.12716012434877 +absorbing-n0010-s01729,absorbing,10,1729,structure/classes-warm/consumed,22.57685182251787 +absorbing-n0010-s01729,absorbing,10,1729,structure/irreducible-cold,12.384043048906232 +absorbing-n0010-s01729,absorbing,10,1729,structure/irreducible-warm,23.963544545536397 +absorbing-n0010-s01729,absorbing,10,1729,visits/bounded-expectation/k-10,3.9237722022655706 +absorbing-n0010-s01729,absorbing,10,1729,visits/bounded-expectation/k-100,2.1318977144283995 +absorbing-n0010-s02718,absorbing,10,2718,absorption-time,9.596054817634835 +absorbing-n0010-s02718,absorbing,10,2718,absorption/probabilities,9.266724347390292 +absorbing-n0010-s02718,absorbing,10,2718,construction/public-consumed,58.549780101443424 +absorbing-n0010-s02718,absorbing,10,2718,evolution/k-10,31.511938258214002 +absorbing-n0010-s02718,absorbing,10,2718,evolution/k-100,84.97041470327916 +absorbing-n0010-s02718,absorbing,10,2718,evolution/one-step,122.4546911885714 +absorbing-n0010-s02718,absorbing,10,2718,finite-time/n-step/k-10,17.112721272142384 +absorbing-n0010-s02718,absorbing,10,2718,finite-time/n-step/k-100,15.148106399538882 +absorbing-n0010-s02718,absorbing,10,2718,finite-time/observation/k-10,14.882886470733348 +absorbing-n0010-s02718,absorbing,10,2718,finite-time/observation/k-100,14.383750364908435 +absorbing-n0010-s02718,absorbing,10,2718,finite-time/step,1.1620726089477362 +absorbing-n0010-s02718,absorbing,10,2718,fundamental-matrix,7.260083646967827 +absorbing-n0010-s02718,absorbing,10,2718,hitting-probability/cold-all-states,2.6289190784755085 +absorbing-n0010-s02718,absorbing,10,2718,hitting-time/cold-all-states,6.220454768929477 +absorbing-n0010-s02718,absorbing,10,2718,hitting/bounded/at-most/k-10,13.324608482610154 +absorbing-n0010-s02718,absorbing,10,2718,hitting/bounded/at-most/k-100,17.865618792642387 +absorbing-n0010-s02718,absorbing,10,2718,hitting/bounded/exact/k-10,13.000728682174955 +absorbing-n0010-s02718,absorbing,10,2718,hitting/bounded/exact/k-100,17.97583286342949 +absorbing-n0010-s02718,absorbing,10,2718,hitting/bounded/greater-than/k-10,13.475626724002478 +absorbing-n0010-s02718,absorbing,10,2718,hitting/bounded/greater-than/k-100,17.758878493639312 +absorbing-n0010-s02718,absorbing,10,2718,occupation-matrix,20.93860106355226 +absorbing-n0010-s02718,absorbing,10,2718,power/10,70.66847830533743 +absorbing-n0010-s02718,absorbing,10,2718,power/100,54.99812208723134 +absorbing-n0010-s02718,absorbing,10,2718,power/2,92.12967545583237 +absorbing-n0010-s02718,absorbing,10,2718,return/bounded/k-10,14.583768403794085 +absorbing-n0010-s02718,absorbing,10,2718,return/bounded/k-100,18.569548117081258 +absorbing-n0010-s02718,absorbing,10,2718,stationary,18.366095880038642 +absorbing-n0010-s02718,absorbing,10,2718,structure/classes-cold,9.586269873815738 +absorbing-n0010-s02718,absorbing,10,2718,structure/classes-lifecycle,52.07989567559055 +absorbing-n0010-s02718,absorbing,10,2718,structure/classes-warm/access,25.169001402684138 +absorbing-n0010-s02718,absorbing,10,2718,structure/classes-warm/consumed,22.448107408721576 +absorbing-n0010-s02718,absorbing,10,2718,structure/irreducible-cold,12.839399168561107 +absorbing-n0010-s02718,absorbing,10,2718,structure/irreducible-warm,23.90496974368111 +absorbing-n0010-s02718,absorbing,10,2718,visits/bounded-expectation/k-10,3.8486939544166345 +absorbing-n0010-s02718,absorbing,10,2718,visits/bounded-expectation/k-100,2.1069027331374857 +absorbing-n0010-s31415,absorbing,10,31415,absorption-time,9.96142580376828 +absorbing-n0010-s31415,absorbing,10,31415,absorption/probabilities,9.471026356361357 +absorbing-n0010-s31415,absorbing,10,31415,construction/public-consumed,59.74588100677252 +absorbing-n0010-s31415,absorbing,10,31415,evolution/k-10,31.26338922046669 +absorbing-n0010-s31415,absorbing,10,31415,evolution/k-100,84.85715633105698 +absorbing-n0010-s31415,absorbing,10,31415,evolution/one-step,120.3685410461582 +absorbing-n0010-s31415,absorbing,10,31415,finite-time/n-step/k-10,16.97768289034936 +absorbing-n0010-s31415,absorbing,10,31415,finite-time/n-step/k-100,14.825530828233529 +absorbing-n0010-s31415,absorbing,10,31415,finite-time/observation/k-10,14.87792599882805 +absorbing-n0010-s31415,absorbing,10,31415,finite-time/observation/k-100,14.333028845229876 +absorbing-n0010-s31415,absorbing,10,31415,finite-time/step,1.1666401389810346 +absorbing-n0010-s31415,absorbing,10,31415,fundamental-matrix,7.689948612231533 +absorbing-n0010-s31415,absorbing,10,31415,hitting-probability/cold-all-states,2.67176177654515 +absorbing-n0010-s31415,absorbing,10,31415,hitting-time/cold-all-states,6.2531533372645 +absorbing-n0010-s31415,absorbing,10,31415,hitting/bounded/at-most/k-10,13.072963909839114 +absorbing-n0010-s31415,absorbing,10,31415,hitting/bounded/at-most/k-100,17.746174283601643 +absorbing-n0010-s31415,absorbing,10,31415,hitting/bounded/exact/k-10,13.05024779807872 +absorbing-n0010-s31415,absorbing,10,31415,hitting/bounded/exact/k-100,17.7669834579489 +absorbing-n0010-s31415,absorbing,10,31415,hitting/bounded/greater-than/k-10,13.430074855693622 +absorbing-n0010-s31415,absorbing,10,31415,hitting/bounded/greater-than/k-100,17.901090212299078 +absorbing-n0010-s31415,absorbing,10,31415,occupation-matrix,21.14250532918321 +absorbing-n0010-s31415,absorbing,10,31415,power/10,71.73389807271964 +absorbing-n0010-s31415,absorbing,10,31415,power/100,54.862812754321546 +absorbing-n0010-s31415,absorbing,10,31415,power/2,93.58993495203467 +absorbing-n0010-s31415,absorbing,10,31415,return/bounded/k-10,14.409170551127556 +absorbing-n0010-s31415,absorbing,10,31415,return/bounded/k-100,18.13290706084094 +absorbing-n0010-s31415,absorbing,10,31415,stationary,18.173615210450347 +absorbing-n0010-s31415,absorbing,10,31415,structure/classes-cold,8.423836723365566 +absorbing-n0010-s31415,absorbing,10,31415,structure/classes-lifecycle,50.5133912453012 +absorbing-n0010-s31415,absorbing,10,31415,structure/classes-warm/access,25.342193765804687 +absorbing-n0010-s31415,absorbing,10,31415,structure/classes-warm/consumed,22.233379033941546 +absorbing-n0010-s31415,absorbing,10,31415,structure/irreducible-cold,12.251389987017411 +absorbing-n0010-s31415,absorbing,10,31415,structure/irreducible-warm,23.602150656836955 +absorbing-n0010-s31415,absorbing,10,31415,visits/bounded-expectation/k-10,3.878924262002852 +absorbing-n0010-s31415,absorbing,10,31415,visits/bounded-expectation/k-100,2.120233470969715 +absorbing-n0025-s01729,absorbing,25,1729,absorption-time,9.065879584785673 +absorbing-n0025-s01729,absorbing,25,1729,absorption/probabilities,9.753981237385947 +absorbing-n0025-s01729,absorbing,25,1729,construction/public-consumed,27.09418485741482 +absorbing-n0025-s01729,absorbing,25,1729,evolution/k-10,27.7767042708983 +absorbing-n0025-s01729,absorbing,25,1729,evolution/k-100,31.929984892722107 +absorbing-n0025-s01729,absorbing,25,1729,evolution/one-step,107.25391524797926 +absorbing-n0025-s01729,absorbing,25,1729,finite-time/n-step/k-10,17.02167530101059 +absorbing-n0025-s01729,absorbing,25,1729,finite-time/n-step/k-100,11.401571760811489 +absorbing-n0025-s01729,absorbing,25,1729,finite-time/observation/k-10,13.999532624374321 +absorbing-n0025-s01729,absorbing,25,1729,finite-time/observation/k-100,11.095100482045662 +absorbing-n0025-s01729,absorbing,25,1729,finite-time/step,1.5933539128740202 +absorbing-n0025-s01729,absorbing,25,1729,fundamental-matrix,6.835701925611518 +absorbing-n0025-s01729,absorbing,25,1729,hitting-probability/cold-all-states,1.5388506592003535 +absorbing-n0025-s01729,absorbing,25,1729,hitting-time/cold-all-states,3.3669808357475173 +absorbing-n0025-s01729,absorbing,25,1729,hitting/bounded/at-most/k-10,13.008254312150045 +absorbing-n0025-s01729,absorbing,25,1729,hitting/bounded/at-most/k-100,21.05016865122077 +absorbing-n0025-s01729,absorbing,25,1729,hitting/bounded/exact/k-10,13.890818117773863 +absorbing-n0025-s01729,absorbing,25,1729,hitting/bounded/exact/k-100,20.405704281118602 +absorbing-n0025-s01729,absorbing,25,1729,hitting/bounded/greater-than/k-10,15.229650832053217 +absorbing-n0025-s01729,absorbing,25,1729,hitting/bounded/greater-than/k-100,20.02468721197017 +absorbing-n0025-s01729,absorbing,25,1729,occupation-matrix,24.51636356031884 +absorbing-n0025-s01729,absorbing,25,1729,power/10,32.63463429965234 +absorbing-n0025-s01729,absorbing,25,1729,power/100,27.24887220482995 +absorbing-n0025-s01729,absorbing,25,1729,power/2,40.90052980231152 +absorbing-n0025-s01729,absorbing,25,1729,return/bounded/k-10,15.917289697387352 +absorbing-n0025-s01729,absorbing,25,1729,return/bounded/k-100,20.193588963424606 +absorbing-n0025-s01729,absorbing,25,1729,stationary,21.882511156390258 +absorbing-n0025-s01729,absorbing,25,1729,structure/classes-cold,11.333835756565321 +absorbing-n0025-s01729,absorbing,25,1729,structure/classes-lifecycle,23.639337534884582 +absorbing-n0025-s01729,absorbing,25,1729,structure/classes-warm/access,25.5818189081045 +absorbing-n0025-s01729,absorbing,25,1729,structure/classes-warm/consumed,15.675454554157806 +absorbing-n0025-s01729,absorbing,25,1729,structure/irreducible-cold,14.981623411934883 +absorbing-n0025-s01729,absorbing,25,1729,structure/irreducible-warm,23.791978090305875 +absorbing-n0025-s01729,absorbing,25,1729,visits/bounded-expectation/k-10,5.243829222595942 +absorbing-n0025-s01729,absorbing,25,1729,visits/bounded-expectation/k-100,2.2248212915323045 +absorbing-n0025-s02718,absorbing,25,2718,absorption-time,9.222388695995848 +absorbing-n0025-s02718,absorbing,25,2718,absorption/probabilities,9.76523138834732 +absorbing-n0025-s02718,absorbing,25,2718,construction/public-consumed,27.18317804006504 +absorbing-n0025-s02718,absorbing,25,2718,evolution/k-10,27.8849631229418 +absorbing-n0025-s02718,absorbing,25,2718,evolution/k-100,32.32209510901887 +absorbing-n0025-s02718,absorbing,25,2718,evolution/one-step,106.87593179398193 +absorbing-n0025-s02718,absorbing,25,2718,finite-time/n-step/k-10,16.8105882692076 +absorbing-n0025-s02718,absorbing,25,2718,finite-time/n-step/k-100,11.487651985177958 +absorbing-n0025-s02718,absorbing,25,2718,finite-time/observation/k-10,14.034658929342454 +absorbing-n0025-s02718,absorbing,25,2718,finite-time/observation/k-100,11.21445771837027 +absorbing-n0025-s02718,absorbing,25,2718,finite-time/step,1.5726612567400917 +absorbing-n0025-s02718,absorbing,25,2718,fundamental-matrix,6.636017519892393 +absorbing-n0025-s02718,absorbing,25,2718,hitting-probability/cold-all-states,1.537505300221586 +absorbing-n0025-s02718,absorbing,25,2718,hitting-time/cold-all-states,3.403389922839567 +absorbing-n0025-s02718,absorbing,25,2718,hitting/bounded/at-most/k-10,14.194758564890746 +absorbing-n0025-s02718,absorbing,25,2718,hitting/bounded/at-most/k-100,19.945159466507082 +absorbing-n0025-s02718,absorbing,25,2718,hitting/bounded/exact/k-10,14.832977958902765 +absorbing-n0025-s02718,absorbing,25,2718,hitting/bounded/exact/k-100,23.25394176849149 +absorbing-n0025-s02718,absorbing,25,2718,hitting/bounded/greater-than/k-10,14.438262108287987 +absorbing-n0025-s02718,absorbing,25,2718,hitting/bounded/greater-than/k-100,20.233165845262867 +absorbing-n0025-s02718,absorbing,25,2718,occupation-matrix,24.436170772189367 +absorbing-n0025-s02718,absorbing,25,2718,power/10,32.49217128572074 +absorbing-n0025-s02718,absorbing,25,2718,power/100,26.545394458888023 +absorbing-n0025-s02718,absorbing,25,2718,power/2,41.160294797735226 +absorbing-n0025-s02718,absorbing,25,2718,return/bounded/k-10,15.897685272866187 +absorbing-n0025-s02718,absorbing,25,2718,return/bounded/k-100,20.488288113245655 +absorbing-n0025-s02718,absorbing,25,2718,stationary,22.646494838185042 +absorbing-n0025-s02718,absorbing,25,2718,structure/classes-cold,11.823785160872598 +absorbing-n0025-s02718,absorbing,25,2718,structure/classes-lifecycle,23.372327678319163 +absorbing-n0025-s02718,absorbing,25,2718,structure/classes-warm/access,25.216487010939844 +absorbing-n0025-s02718,absorbing,25,2718,structure/classes-warm/consumed,15.581622888928525 +absorbing-n0025-s02718,absorbing,25,2718,structure/irreducible-cold,15.108617610192422 +absorbing-n0025-s02718,absorbing,25,2718,structure/irreducible-warm,23.767376664984702 +absorbing-n0025-s02718,absorbing,25,2718,visits/bounded-expectation/k-10,5.229914134405807 +absorbing-n0025-s02718,absorbing,25,2718,visits/bounded-expectation/k-100,2.1780896016535722 +absorbing-n0025-s31415,absorbing,25,31415,absorption-time,9.13143885420628 +absorbing-n0025-s31415,absorbing,25,31415,absorption/probabilities,9.952582137459624 +absorbing-n0025-s31415,absorbing,25,31415,construction/public-consumed,27.14055850603354 +absorbing-n0025-s31415,absorbing,25,31415,evolution/k-10,27.93909968518145 +absorbing-n0025-s31415,absorbing,25,31415,evolution/k-100,28.361527070278292 +absorbing-n0025-s31415,absorbing,25,31415,evolution/one-step,108.01840149275021 +absorbing-n0025-s31415,absorbing,25,31415,finite-time/n-step/k-10,17.17267136503694 +absorbing-n0025-s31415,absorbing,25,31415,finite-time/n-step/k-100,11.447445528753722 +absorbing-n0025-s31415,absorbing,25,31415,finite-time/observation/k-10,14.35239806602099 +absorbing-n0025-s31415,absorbing,25,31415,finite-time/observation/k-100,11.164040024408491 +absorbing-n0025-s31415,absorbing,25,31415,finite-time/step,1.5694031862336744 +absorbing-n0025-s31415,absorbing,25,31415,fundamental-matrix,6.77911176853103 +absorbing-n0025-s31415,absorbing,25,31415,hitting-probability/cold-all-states,1.5711894069746997 +absorbing-n0025-s31415,absorbing,25,31415,hitting-time/cold-all-states,3.4235294160978147 +absorbing-n0025-s31415,absorbing,25,31415,hitting/bounded/at-most/k-10,15.01352154892945 +absorbing-n0025-s31415,absorbing,25,31415,hitting/bounded/at-most/k-100,20.171261079488605 +absorbing-n0025-s31415,absorbing,25,31415,hitting/bounded/exact/k-10,14.275219579715381 +absorbing-n0025-s31415,absorbing,25,31415,hitting/bounded/exact/k-100,20.524204757726 +absorbing-n0025-s31415,absorbing,25,31415,hitting/bounded/greater-than/k-10,15.299770404618954 +absorbing-n0025-s31415,absorbing,25,31415,hitting/bounded/greater-than/k-100,19.965823073538683 +absorbing-n0025-s31415,absorbing,25,31415,occupation-matrix,24.607504532992515 +absorbing-n0025-s31415,absorbing,25,31415,power/10,32.66229606960313 +absorbing-n0025-s31415,absorbing,25,31415,power/100,26.98953085294204 +absorbing-n0025-s31415,absorbing,25,31415,power/2,40.59596710965171 +absorbing-n0025-s31415,absorbing,25,31415,return/bounded/k-10,16.39254436460928 +absorbing-n0025-s31415,absorbing,25,31415,return/bounded/k-100,20.64810289802087 +absorbing-n0025-s31415,absorbing,25,31415,stationary,22.283813422046514 +absorbing-n0025-s31415,absorbing,25,31415,structure/classes-cold,11.513058804536579 +absorbing-n0025-s31415,absorbing,25,31415,structure/classes-lifecycle,23.643599719824607 +absorbing-n0025-s31415,absorbing,25,31415,structure/classes-warm/access,23.7496970085084 +absorbing-n0025-s31415,absorbing,25,31415,structure/classes-warm/consumed,15.664766503689458 +absorbing-n0025-s31415,absorbing,25,31415,structure/irreducible-cold,14.760836443916693 +absorbing-n0025-s31415,absorbing,25,31415,structure/irreducible-warm,23.835901681836695 +absorbing-n0025-s31415,absorbing,25,31415,visits/bounded-expectation/k-10,5.182997690655519 +absorbing-n0025-s31415,absorbing,25,31415,visits/bounded-expectation/k-100,2.220474620138966 +absorbing-n0050-s01729,absorbing,50,1729,absorption-time,8.314387980211297 +absorbing-n0050-s01729,absorbing,50,1729,absorption/probabilities,9.46520578745596 +absorbing-n0050-s01729,absorbing,50,1729,construction/public-consumed,22.857995277039013 +absorbing-n0050-s01729,absorbing,50,1729,evolution/k-10,20.17587223853938 +absorbing-n0050-s01729,absorbing,50,1729,evolution/k-100,15.665262125578838 +absorbing-n0050-s01729,absorbing,50,1729,evolution/one-step,78.50479037981177 +absorbing-n0050-s01729,absorbing,50,1729,finite-time/n-step/k-10,14.92738551071125 +absorbing-n0050-s01729,absorbing,50,1729,finite-time/n-step/k-100,7.26572984145074 +absorbing-n0050-s01729,absorbing,50,1729,finite-time/observation/k-10,11.897075067565337 +absorbing-n0050-s01729,absorbing,50,1729,finite-time/observation/k-100,7.1469457927424624 +absorbing-n0050-s01729,absorbing,50,1729,finite-time/step,1.8880514585766561 +absorbing-n0050-s01729,absorbing,50,1729,fundamental-matrix,5.84710233238063 +absorbing-n0050-s01729,absorbing,50,1729,hitting-probability/cold-all-states,1.317306673304277 +absorbing-n0050-s01729,absorbing,50,1729,hitting-time/cold-all-states,2.735496321049826 +absorbing-n0050-s01729,absorbing,50,1729,hitting/bounded/at-most/k-10,12.759038094284179 +absorbing-n0050-s01729,absorbing,50,1729,hitting/bounded/at-most/k-100,16.622176755966603 +absorbing-n0050-s01729,absorbing,50,1729,hitting/bounded/exact/k-10,12.728363315352224 +absorbing-n0050-s01729,absorbing,50,1729,hitting/bounded/exact/k-100,16.284923874647053 +absorbing-n0050-s01729,absorbing,50,1729,hitting/bounded/greater-than/k-10,12.874693153851661 +absorbing-n0050-s01729,absorbing,50,1729,hitting/bounded/greater-than/k-100,16.489403933472655 +absorbing-n0050-s01729,absorbing,50,1729,occupation-matrix,24.405933900798683 +absorbing-n0050-s01729,absorbing,50,1729,power/10,28.858290085351843 +absorbing-n0050-s01729,absorbing,50,1729,power/100,23.880436288784914 +absorbing-n0050-s01729,absorbing,50,1729,power/2,33.307434459453816 +absorbing-n0050-s01729,absorbing,50,1729,return/bounded/k-10,14.560997241023829 +absorbing-n0050-s01729,absorbing,50,1729,return/bounded/k-100,16.62685850998233 +absorbing-n0050-s01729,absorbing,50,1729,stationary,24.777072517798214 +absorbing-n0050-s01729,absorbing,50,1729,structure/classes-cold,13.34374315798667 +absorbing-n0050-s01729,absorbing,50,1729,structure/classes-lifecycle,19.38118830209466 +absorbing-n0050-s01729,absorbing,50,1729,structure/classes-warm/access,25.379610288657396 +absorbing-n0050-s01729,absorbing,50,1729,structure/classes-warm/consumed,12.31146377110581 +absorbing-n0050-s01729,absorbing,50,1729,structure/irreducible-cold,14.78954375931573 +absorbing-n0050-s01729,absorbing,50,1729,structure/irreducible-warm,23.907400258292075 +absorbing-n0050-s01729,absorbing,50,1729,visits/bounded-expectation/k-10,6.257552932628467 +absorbing-n0050-s01729,absorbing,50,1729,visits/bounded-expectation/k-100,2.0253842794194483 +absorbing-n0050-s02718,absorbing,50,2718,absorption-time,8.207261869164025 +absorbing-n0050-s02718,absorbing,50,2718,absorption/probabilities,9.879758526087072 +absorbing-n0050-s02718,absorbing,50,2718,construction/public-consumed,22.6905398068849 +absorbing-n0050-s02718,absorbing,50,2718,evolution/k-10,20.10594155509573 +absorbing-n0050-s02718,absorbing,50,2718,evolution/k-100,15.536209541413852 +absorbing-n0050-s02718,absorbing,50,2718,evolution/one-step,85.97865628827306 +absorbing-n0050-s02718,absorbing,50,2718,finite-time/n-step/k-10,15.01937524629347 +absorbing-n0050-s02718,absorbing,50,2718,finite-time/n-step/k-100,7.450279257986244 +absorbing-n0050-s02718,absorbing,50,2718,finite-time/observation/k-10,11.985414437963739 +absorbing-n0050-s02718,absorbing,50,2718,finite-time/observation/k-100,7.139785605019681 +absorbing-n0050-s02718,absorbing,50,2718,finite-time/step,1.9694687970954081 +absorbing-n0050-s02718,absorbing,50,2718,fundamental-matrix,5.9397942243530055 +absorbing-n0050-s02718,absorbing,50,2718,hitting-probability/cold-all-states,1.3186843827342019 +absorbing-n0050-s02718,absorbing,50,2718,hitting-time/cold-all-states,2.7514049123282986 +absorbing-n0050-s02718,absorbing,50,2718,hitting/bounded/at-most/k-10,12.960273156013605 +absorbing-n0050-s02718,absorbing,50,2718,hitting/bounded/at-most/k-100,16.511772928613595 +absorbing-n0050-s02718,absorbing,50,2718,hitting/bounded/exact/k-10,12.901170944593042 +absorbing-n0050-s02718,absorbing,50,2718,hitting/bounded/exact/k-100,16.616811745520003 +absorbing-n0050-s02718,absorbing,50,2718,hitting/bounded/greater-than/k-10,13.02249406271524 +absorbing-n0050-s02718,absorbing,50,2718,hitting/bounded/greater-than/k-100,16.620262918752402 +absorbing-n0050-s02718,absorbing,50,2718,occupation-matrix,24.366576622336318 +absorbing-n0050-s02718,absorbing,50,2718,power/10,28.714877146619543 +absorbing-n0050-s02718,absorbing,50,2718,power/100,24.192371702583717 +absorbing-n0050-s02718,absorbing,50,2718,power/2,33.355452846502196 +absorbing-n0050-s02718,absorbing,50,2718,return/bounded/k-10,14.861041881689294 +absorbing-n0050-s02718,absorbing,50,2718,return/bounded/k-100,15.957652204580981 +absorbing-n0050-s02718,absorbing,50,2718,stationary,24.5111484627047 +absorbing-n0050-s02718,absorbing,50,2718,structure/classes-cold,13.13248346075636 +absorbing-n0050-s02718,absorbing,50,2718,structure/classes-lifecycle,19.214694497556238 +absorbing-n0050-s02718,absorbing,50,2718,structure/classes-warm/access,25.27015132335678 +absorbing-n0050-s02718,absorbing,50,2718,structure/classes-warm/consumed,12.70699891185319 +absorbing-n0050-s02718,absorbing,50,2718,structure/irreducible-cold,15.140005377207261 +absorbing-n0050-s02718,absorbing,50,2718,structure/irreducible-warm,23.9517913314551 +absorbing-n0050-s02718,absorbing,50,2718,visits/bounded-expectation/k-10,6.280853195993583 +absorbing-n0050-s02718,absorbing,50,2718,visits/bounded-expectation/k-100,2.016648705437416 +absorbing-n0050-s31415,absorbing,50,31415,absorption-time,8.169703024456961 +absorbing-n0050-s31415,absorbing,50,31415,absorption/probabilities,9.637757245200008 +absorbing-n0050-s31415,absorbing,50,31415,construction/public-consumed,22.566321912314923 +absorbing-n0050-s31415,absorbing,50,31415,evolution/k-10,20.090588823429293 +absorbing-n0050-s31415,absorbing,50,31415,evolution/k-100,15.563836095212434 +absorbing-n0050-s31415,absorbing,50,31415,evolution/one-step,85.69565003591894 +absorbing-n0050-s31415,absorbing,50,31415,finite-time/n-step/k-10,15.033809739635792 +absorbing-n0050-s31415,absorbing,50,31415,finite-time/n-step/k-100,7.409163790893876 +absorbing-n0050-s31415,absorbing,50,31415,finite-time/observation/k-10,11.978090594498802 +absorbing-n0050-s31415,absorbing,50,31415,finite-time/observation/k-100,7.142497296803202 +absorbing-n0050-s31415,absorbing,50,31415,finite-time/step,2.017108527625137 +absorbing-n0050-s31415,absorbing,50,31415,fundamental-matrix,5.867982453604837 +absorbing-n0050-s31415,absorbing,50,31415,hitting-probability/cold-all-states,1.3123987420735628 +absorbing-n0050-s31415,absorbing,50,31415,hitting-time/cold-all-states,2.7376162605681564 +absorbing-n0050-s31415,absorbing,50,31415,hitting/bounded/at-most/k-10,13.120538766522344 +absorbing-n0050-s31415,absorbing,50,31415,hitting/bounded/at-most/k-100,16.18026139799287 +absorbing-n0050-s31415,absorbing,50,31415,hitting/bounded/exact/k-10,14.794238598944489 +absorbing-n0050-s31415,absorbing,50,31415,hitting/bounded/exact/k-100,16.866456113117746 +absorbing-n0050-s31415,absorbing,50,31415,hitting/bounded/greater-than/k-10,13.018174159660871 +absorbing-n0050-s31415,absorbing,50,31415,hitting/bounded/greater-than/k-100,16.59521079163669 +absorbing-n0050-s31415,absorbing,50,31415,occupation-matrix,24.305553523772367 +absorbing-n0050-s31415,absorbing,50,31415,power/10,26.036767627163503 +absorbing-n0050-s31415,absorbing,50,31415,power/100,24.00695131927481 +absorbing-n0050-s31415,absorbing,50,31415,power/2,33.38241758182088 +absorbing-n0050-s31415,absorbing,50,31415,return/bounded/k-10,14.830990329099928 +absorbing-n0050-s31415,absorbing,50,31415,return/bounded/k-100,16.99859519593035 +absorbing-n0050-s31415,absorbing,50,31415,stationary,24.47327029262887 +absorbing-n0050-s31415,absorbing,50,31415,structure/classes-cold,13.058045244619374 +absorbing-n0050-s31415,absorbing,50,31415,structure/classes-lifecycle,19.24878949131177 +absorbing-n0050-s31415,absorbing,50,31415,structure/classes-warm/access,25.31726569083991 +absorbing-n0050-s31415,absorbing,50,31415,structure/classes-warm/consumed,12.691834152500526 +absorbing-n0050-s31415,absorbing,50,31415,structure/irreducible-cold,14.935004220973333 +absorbing-n0050-s31415,absorbing,50,31415,structure/irreducible-warm,23.99694824527575 +absorbing-n0050-s31415,absorbing,50,31415,visits/bounded-expectation/k-10,6.346129992791766 +absorbing-n0050-s31415,absorbing,50,31415,visits/bounded-expectation/k-100,2.029559437510722 +absorbing-n0100-s01729,absorbing,100,1729,absorption-time,7.514895722650851 +absorbing-n0100-s01729,absorbing,100,1729,absorption/probabilities,9.525258570011712 +absorbing-n0100-s01729,absorbing,100,1729,construction/public-consumed,21.536387749691524 +absorbing-n0100-s01729,absorbing,100,1729,evolution/k-10,13.884458410330117 +absorbing-n0100-s01729,absorbing,100,1729,evolution/k-100,4.659695592114022 +absorbing-n0100-s01729,absorbing,100,1729,evolution/one-step,66.98021102608564 +absorbing-n0100-s01729,absorbing,100,1729,finite-time/n-step/k-10,11.602337136506039 +absorbing-n0100-s01729,absorbing,100,1729,finite-time/n-step/k-100,4.551921748336093 +absorbing-n0100-s01729,absorbing,100,1729,finite-time/observation/k-10,9.58325555629151 +absorbing-n0100-s01729,absorbing,100,1729,finite-time/observation/k-100,4.4473886075106 +absorbing-n0100-s01729,absorbing,100,1729,finite-time/step,3.529024576151523 +absorbing-n0100-s01729,absorbing,100,1729,fundamental-matrix,5.264985411572528 +absorbing-n0100-s01729,absorbing,100,1729,hitting-probability/cold-all-states,1.8501008449372156 +absorbing-n0100-s01729,absorbing,100,1729,hitting-time/cold-all-states,3.7600582459294376 +absorbing-n0100-s01729,absorbing,100,1729,hitting/bounded/at-most/k-10,12.664443948829453 +absorbing-n0100-s01729,absorbing,100,1729,hitting/bounded/at-most/k-100,16.62989542398036 +absorbing-n0100-s01729,absorbing,100,1729,hitting/bounded/exact/k-10,12.748263351729033 +absorbing-n0100-s01729,absorbing,100,1729,hitting/bounded/exact/k-100,16.587123371866245 +absorbing-n0100-s01729,absorbing,100,1729,hitting/bounded/greater-than/k-10,12.832997787338416 +absorbing-n0100-s01729,absorbing,100,1729,hitting/bounded/greater-than/k-100,16.562121851421654 +absorbing-n0100-s01729,absorbing,100,1729,occupation-matrix,19.97524027970952 +absorbing-n0100-s01729,absorbing,100,1729,power/10,28.048209496108818 +absorbing-n0100-s01729,absorbing,100,1729,power/100,22.949652191200386 +absorbing-n0100-s01729,absorbing,100,1729,power/2,35.186740274418206 +absorbing-n0100-s01729,absorbing,100,1729,return/bounded/k-10,18.915268350163018 +absorbing-n0100-s01729,absorbing,100,1729,return/bounded/k-100,16.862456251065787 +absorbing-n0100-s01729,absorbing,100,1729,stationary,23.527324492623308 +absorbing-n0100-s01729,absorbing,100,1729,structure/classes-cold,12.91049171702441 +absorbing-n0100-s01729,absorbing,100,1729,structure/classes-lifecycle,16.22451142481238 +absorbing-n0100-s01729,absorbing,100,1729,structure/classes-warm/access,25.259830943818137 +absorbing-n0100-s01729,absorbing,100,1729,structure/classes-warm/consumed,11.339067704393022 +absorbing-n0100-s01729,absorbing,100,1729,structure/irreducible-cold,14.178067286143431 +absorbing-n0100-s01729,absorbing,100,1729,structure/irreducible-warm,24.04488123220437 +absorbing-n0100-s01729,absorbing,100,1729,visits/bounded-expectation/k-10,6.426483002626238 +absorbing-n0100-s01729,absorbing,100,1729,visits/bounded-expectation/k-100,1.8281991729940232 +absorbing-n0100-s02718,absorbing,100,2718,absorption-time,7.6833032216144765 +absorbing-n0100-s02718,absorbing,100,2718,absorption/probabilities,9.344836071617731 +absorbing-n0100-s02718,absorbing,100,2718,construction/public-consumed,21.42982437696184 +absorbing-n0100-s02718,absorbing,100,2718,evolution/k-10,13.738702957818022 +absorbing-n0100-s02718,absorbing,100,2718,evolution/k-100,4.6602024023443755 +absorbing-n0100-s02718,absorbing,100,2718,evolution/one-step,62.39286207725884 +absorbing-n0100-s02718,absorbing,100,2718,finite-time/n-step/k-10,11.508504617428194 +absorbing-n0100-s02718,absorbing,100,2718,finite-time/n-step/k-100,4.550264700819336 +absorbing-n0100-s02718,absorbing,100,2718,finite-time/observation/k-10,9.632874018105984 +absorbing-n0100-s02718,absorbing,100,2718,finite-time/observation/k-100,4.430609731841902 +absorbing-n0100-s02718,absorbing,100,2718,finite-time/step,3.9367660123223382 +absorbing-n0100-s02718,absorbing,100,2718,fundamental-matrix,5.187473723837208 +absorbing-n0100-s02718,absorbing,100,2718,hitting-probability/cold-all-states,1.848433459897863 +absorbing-n0100-s02718,absorbing,100,2718,hitting-time/cold-all-states,3.7488932014344907 +absorbing-n0100-s02718,absorbing,100,2718,hitting/bounded/at-most/k-10,12.701876572310193 +absorbing-n0100-s02718,absorbing,100,2718,hitting/bounded/at-most/k-100,15.49643126253659 +absorbing-n0100-s02718,absorbing,100,2718,hitting/bounded/exact/k-10,12.71427184977732 +absorbing-n0100-s02718,absorbing,100,2718,hitting/bounded/exact/k-100,16.561814803684907 +absorbing-n0100-s02718,absorbing,100,2718,hitting/bounded/greater-than/k-10,12.459853166068662 +absorbing-n0100-s02718,absorbing,100,2718,hitting/bounded/greater-than/k-100,16.403151143942733 +absorbing-n0100-s02718,absorbing,100,2718,occupation-matrix,20.021564103958056 +absorbing-n0100-s02718,absorbing,100,2718,power/10,28.487865714442954 +absorbing-n0100-s02718,absorbing,100,2718,power/100,23.05625048541852 +absorbing-n0100-s02718,absorbing,100,2718,power/2,35.96039434433907 +absorbing-n0100-s02718,absorbing,100,2718,return/bounded/k-10,14.119400110367442 +absorbing-n0100-s02718,absorbing,100,2718,return/bounded/k-100,16.795110621279626 +absorbing-n0100-s02718,absorbing,100,2718,stationary,23.520838367763584 +absorbing-n0100-s02718,absorbing,100,2718,structure/classes-cold,13.029254195990855 +absorbing-n0100-s02718,absorbing,100,2718,structure/classes-lifecycle,16.083280097472194 +absorbing-n0100-s02718,absorbing,100,2718,structure/classes-warm/access,25.36179938615536 +absorbing-n0100-s02718,absorbing,100,2718,structure/classes-warm/consumed,11.329120122175103 +absorbing-n0100-s02718,absorbing,100,2718,structure/irreducible-cold,13.880968131851368 +absorbing-n0100-s02718,absorbing,100,2718,structure/irreducible-warm,24.189169553743874 +absorbing-n0100-s02718,absorbing,100,2718,visits/bounded-expectation/k-10,6.394785497476969 +absorbing-n0100-s02718,absorbing,100,2718,visits/bounded-expectation/k-100,1.8388960293594638 +absorbing-n0100-s31415,absorbing,100,31415,absorption-time,7.631230883044431 +absorbing-n0100-s31415,absorbing,100,31415,absorption/probabilities,9.527464763946032 +absorbing-n0100-s31415,absorbing,100,31415,construction/public-consumed,21.85319482390747 +absorbing-n0100-s31415,absorbing,100,31415,evolution/k-10,13.782250992146215 +absorbing-n0100-s31415,absorbing,100,31415,evolution/k-100,4.653856228453342 +absorbing-n0100-s31415,absorbing,100,31415,evolution/one-step,67.16850455671911 +absorbing-n0100-s31415,absorbing,100,31415,finite-time/n-step/k-10,10.9926014136276 +absorbing-n0100-s31415,absorbing,100,31415,finite-time/n-step/k-100,4.599910334999508 +absorbing-n0100-s31415,absorbing,100,31415,finite-time/observation/k-10,9.177001287162332 +absorbing-n0100-s31415,absorbing,100,31415,finite-time/observation/k-100,4.910323802536174 +absorbing-n0100-s31415,absorbing,100,31415,finite-time/step,3.4483050075559945 +absorbing-n0100-s31415,absorbing,100,31415,fundamental-matrix,5.254377825029163 +absorbing-n0100-s31415,absorbing,100,31415,hitting-probability/cold-all-states,1.8526028370865673 +absorbing-n0100-s31415,absorbing,100,31415,hitting-time/cold-all-states,3.759479564917154 +absorbing-n0100-s31415,absorbing,100,31415,hitting/bounded/at-most/k-10,11.967234762579071 +absorbing-n0100-s31415,absorbing,100,31415,hitting/bounded/at-most/k-100,16.4671275412379 +absorbing-n0100-s31415,absorbing,100,31415,hitting/bounded/exact/k-10,14.264130818562666 +absorbing-n0100-s31415,absorbing,100,31415,hitting/bounded/exact/k-100,16.478394557664878 +absorbing-n0100-s31415,absorbing,100,31415,hitting/bounded/greater-than/k-10,12.15166628065049 +absorbing-n0100-s31415,absorbing,100,31415,hitting/bounded/greater-than/k-100,16.465677255514674 +absorbing-n0100-s31415,absorbing,100,31415,occupation-matrix,20.06426113961099 +absorbing-n0100-s31415,absorbing,100,31415,power/10,29.067080734453825 +absorbing-n0100-s31415,absorbing,100,31415,power/100,22.919465714608037 +absorbing-n0100-s31415,absorbing,100,31415,power/2,35.242835778254076 +absorbing-n0100-s31415,absorbing,100,31415,return/bounded/k-10,13.380972682488448 +absorbing-n0100-s31415,absorbing,100,31415,return/bounded/k-100,16.82112031518424 +absorbing-n0100-s31415,absorbing,100,31415,stationary,23.96049805713125 +absorbing-n0100-s31415,absorbing,100,31415,structure/classes-cold,13.015994238912677 +absorbing-n0100-s31415,absorbing,100,31415,structure/classes-lifecycle,16.10973296699256 +absorbing-n0100-s31415,absorbing,100,31415,structure/classes-warm/access,25.14532757497677 +absorbing-n0100-s31415,absorbing,100,31415,structure/classes-warm/consumed,11.344593724907206 +absorbing-n0100-s31415,absorbing,100,31415,structure/irreducible-cold,13.934811128772767 +absorbing-n0100-s31415,absorbing,100,31415,structure/irreducible-warm,24.03072846920001 +absorbing-n0100-s31415,absorbing,100,31415,visits/bounded-expectation/k-10,6.06238046945123 +absorbing-n0100-s31415,absorbing,100,31415,visits/bounded-expectation/k-100,1.8277875655284914 +absorbing-n0250-s01729,absorbing,250,1729,absorption-time,5.409308454965462 +absorbing-n0250-s01729,absorbing,250,1729,absorption/probabilities,8.92728938416644 +absorbing-n0250-s01729,absorbing,250,1729,construction/public-consumed,15.056337192711258 +absorbing-n0250-s01729,absorbing,250,1729,evolution/k-10,5.294720740659737 +absorbing-n0250-s01729,absorbing,250,1729,evolution/k-100,1.7821653287622055 +absorbing-n0250-s01729,absorbing,250,1729,evolution/one-step,34.6420236480178 +absorbing-n0250-s01729,absorbing,250,1729,fundamental-matrix,4.432377491828909 +absorbing-n0250-s01729,absorbing,250,1729,hitting-probability/cold-all-states,2.925499024223099 +absorbing-n0250-s01729,absorbing,250,1729,hitting-time/cold-all-states,5.800338293052049 +absorbing-n0250-s01729,absorbing,250,1729,occupation-matrix,14.979404926585662 +absorbing-n0250-s01729,absorbing,250,1729,power/10,25.586158560801742 +absorbing-n0250-s01729,absorbing,250,1729,power/100,18.349700352366416 +absorbing-n0250-s01729,absorbing,250,1729,power/2,35.20115311427802 +absorbing-n0250-s01729,absorbing,250,1729,stationary,21.794101579780072 +absorbing-n0250-s01729,absorbing,250,1729,structure/classes-cold,11.972643992120954 +absorbing-n0250-s01729,absorbing,250,1729,structure/classes-lifecycle,10.971094432662017 +absorbing-n0250-s01729,absorbing,250,1729,structure/classes-warm/access,24.22412357812169 +absorbing-n0250-s01729,absorbing,250,1729,structure/classes-warm/consumed,10.741956645666491 +absorbing-n0250-s01729,absorbing,250,1729,structure/irreducible-cold,12.137840405865422 +absorbing-n0250-s01729,absorbing,250,1729,structure/irreducible-warm,23.799569678837962 +absorbing-n0250-s02718,absorbing,250,2718,absorption-time,5.500747514209653 +absorbing-n0250-s02718,absorbing,250,2718,absorption/probabilities,8.970799231195969 +absorbing-n0250-s02718,absorbing,250,2718,construction/public-consumed,15.01198620876072 +absorbing-n0250-s02718,absorbing,250,2718,evolution/k-10,5.375426803267679 +absorbing-n0250-s02718,absorbing,250,2718,evolution/k-100,1.7793007548739983 +absorbing-n0250-s02718,absorbing,250,2718,evolution/one-step,34.52282924768032 +absorbing-n0250-s02718,absorbing,250,2718,fundamental-matrix,4.484757474145257 +absorbing-n0250-s02718,absorbing,250,2718,hitting-probability/cold-all-states,2.927688980311017 +absorbing-n0250-s02718,absorbing,250,2718,hitting-time/cold-all-states,5.835483086379581 +absorbing-n0250-s02718,absorbing,250,2718,occupation-matrix,15.763131279462367 +absorbing-n0250-s02718,absorbing,250,2718,power/10,26.260978212201117 +absorbing-n0250-s02718,absorbing,250,2718,power/100,18.638925863826334 +absorbing-n0250-s02718,absorbing,250,2718,power/2,35.18090770663964 +absorbing-n0250-s02718,absorbing,250,2718,stationary,22.11594165637662 +absorbing-n0250-s02718,absorbing,250,2718,structure/classes-cold,11.887400669325146 +absorbing-n0250-s02718,absorbing,250,2718,structure/classes-lifecycle,11.094480251921052 +absorbing-n0250-s02718,absorbing,250,2718,structure/classes-warm/access,25.333068584460058 +absorbing-n0250-s02718,absorbing,250,2718,structure/classes-warm/consumed,10.74442932629967 +absorbing-n0250-s02718,absorbing,250,2718,structure/irreducible-cold,12.225344664452892 +absorbing-n0250-s02718,absorbing,250,2718,structure/irreducible-warm,23.787346727558457 +absorbing-n0250-s31415,absorbing,250,31415,absorption-time,5.405407314042524 +absorbing-n0250-s31415,absorbing,250,31415,absorption/probabilities,8.73384805770177 +absorbing-n0250-s31415,absorbing,250,31415,construction/public-consumed,15.224983130554579 +absorbing-n0250-s31415,absorbing,250,31415,evolution/k-10,5.567965943064261 +absorbing-n0250-s31415,absorbing,250,31415,evolution/k-100,1.7971434447923043 +absorbing-n0250-s31415,absorbing,250,31415,evolution/one-step,38.21919811414531 +absorbing-n0250-s31415,absorbing,250,31415,fundamental-matrix,4.269317178213401 +absorbing-n0250-s31415,absorbing,250,31415,hitting-probability/cold-all-states,2.8694073349197913 +absorbing-n0250-s31415,absorbing,250,31415,hitting-time/cold-all-states,5.666093854018265 +absorbing-n0250-s31415,absorbing,250,31415,occupation-matrix,14.600850075667543 +absorbing-n0250-s31415,absorbing,250,31415,power/10,25.638244598176183 +absorbing-n0250-s31415,absorbing,250,31415,power/100,18.546869191180228 +absorbing-n0250-s31415,absorbing,250,31415,power/2,35.27586156853484 +absorbing-n0250-s31415,absorbing,250,31415,stationary,21.49474593377864 +absorbing-n0250-s31415,absorbing,250,31415,structure/classes-cold,11.997027003900737 +absorbing-n0250-s31415,absorbing,250,31415,structure/classes-lifecycle,11.060723039059313 +absorbing-n0250-s31415,absorbing,250,31415,structure/classes-warm/access,23.417706375202613 +absorbing-n0250-s31415,absorbing,250,31415,structure/classes-warm/consumed,10.220122554187661 +absorbing-n0250-s31415,absorbing,250,31415,structure/irreducible-cold,11.972242563593383 +absorbing-n0250-s31415,absorbing,250,31415,structure/irreducible-warm,23.52487380830844 +absorbing-n0500-s01729,absorbing,500,1729,absorption-time,3.0975200386136943 +absorbing-n0500-s01729,absorbing,500,1729,absorption/probabilities,4.428709774945363 +absorbing-n0500-s01729,absorbing,500,1729,construction/public-consumed,10.545913310323703 +absorbing-n0500-s01729,absorbing,500,1729,evolution/k-10,3.439665387197909 +absorbing-n0500-s01729,absorbing,500,1729,evolution/k-100,1.4015498993666111 +absorbing-n0500-s01729,absorbing,500,1729,evolution/one-step,22.10695990656161 +absorbing-n0500-s01729,absorbing,500,1729,fundamental-matrix,3.34869423874261 +absorbing-n0500-s01729,absorbing,500,1729,hitting-probability/cold-all-states,2.9460836369470598 +absorbing-n0500-s01729,absorbing,500,1729,hitting-time/cold-all-states,5.9844555293958015 +absorbing-n0500-s01729,absorbing,500,1729,power/10,18.0189245456634 +absorbing-n0500-s01729,absorbing,500,1729,power/100,11.30674055982579 +absorbing-n0500-s01729,absorbing,500,1729,power/2,28.23032439314545 +absorbing-n0500-s01729,absorbing,500,1729,stationary,11.014255441033844 +absorbing-n0500-s01729,absorbing,500,1729,structure/classes-cold,5.3637015191930315 +absorbing-n0500-s01729,absorbing,500,1729,structure/classes-lifecycle,7.706091343606842 +absorbing-n0500-s01729,absorbing,500,1729,structure/classes-warm/access,23.9468453589469 +absorbing-n0500-s01729,absorbing,500,1729,structure/classes-warm/consumed,11.345495307437083 +absorbing-n0500-s01729,absorbing,500,1729,structure/irreducible-cold,5.883415300900271 +absorbing-n0500-s01729,absorbing,500,1729,structure/irreducible-warm,23.699766907326985 +absorbing-n0500-s02718,absorbing,500,2718,absorption-time,3.2335912762043613 +absorbing-n0500-s02718,absorbing,500,2718,absorption/probabilities,4.099799557852052 +absorbing-n0500-s02718,absorbing,500,2718,construction/public-consumed,11.333220912645654 +absorbing-n0500-s02718,absorbing,500,2718,evolution/k-10,3.5029904202402706 +absorbing-n0500-s02718,absorbing,500,2718,evolution/k-100,1.3967963726705295 +absorbing-n0500-s02718,absorbing,500,2718,evolution/one-step,22.427027026476015 +absorbing-n0500-s02718,absorbing,500,2718,fundamental-matrix,3.343858729482268 +absorbing-n0500-s02718,absorbing,500,2718,hitting-probability/cold-all-states,2.9841791296701725 +absorbing-n0500-s02718,absorbing,500,2718,hitting-time/cold-all-states,6.04006010614908 +absorbing-n0500-s02718,absorbing,500,2718,power/10,18.287541617281118 +absorbing-n0500-s02718,absorbing,500,2718,power/100,11.399851130056783 +absorbing-n0500-s02718,absorbing,500,2718,power/2,27.424734144184807 +absorbing-n0500-s02718,absorbing,500,2718,stationary,11.942480482128907 +absorbing-n0500-s02718,absorbing,500,2718,structure/classes-cold,6.394207890101479 +absorbing-n0500-s02718,absorbing,500,2718,structure/classes-lifecycle,7.859205296386527 +absorbing-n0500-s02718,absorbing,500,2718,structure/classes-warm/access,25.106703099665765 +absorbing-n0500-s02718,absorbing,500,2718,structure/classes-warm/consumed,10.951674704568362 +absorbing-n0500-s02718,absorbing,500,2718,structure/irreducible-cold,5.9035470510052965 +absorbing-n0500-s02718,absorbing,500,2718,structure/irreducible-warm,23.662777853627272 +absorbing-n0500-s31415,absorbing,500,31415,absorption-time,3.1797753996158655 +absorbing-n0500-s31415,absorbing,500,31415,absorption/probabilities,4.266060849116532 +absorbing-n0500-s31415,absorbing,500,31415,construction/public-consumed,11.111980435726954 +absorbing-n0500-s31415,absorbing,500,31415,evolution/k-10,3.5649239030843654 +absorbing-n0500-s31415,absorbing,500,31415,evolution/k-100,1.4019314560895 +absorbing-n0500-s31415,absorbing,500,31415,evolution/one-step,22.41446754600592 +absorbing-n0500-s31415,absorbing,500,31415,fundamental-matrix,3.182616911438281 +absorbing-n0500-s31415,absorbing,500,31415,hitting-probability/cold-all-states,2.9981727066833757 +absorbing-n0500-s31415,absorbing,500,31415,hitting-time/cold-all-states,5.166460397067625 +absorbing-n0500-s31415,absorbing,500,31415,power/10,17.784244298358075 +absorbing-n0500-s31415,absorbing,500,31415,power/100,11.303121071063895 +absorbing-n0500-s31415,absorbing,500,31415,power/2,28.94104351282632 +absorbing-n0500-s31415,absorbing,500,31415,stationary,12.054973358073768 +absorbing-n0500-s31415,absorbing,500,31415,structure/classes-cold,6.117284546028949 +absorbing-n0500-s31415,absorbing,500,31415,structure/classes-lifecycle,7.691460582106316 +absorbing-n0500-s31415,absorbing,500,31415,structure/classes-warm/access,25.150496061342736 +absorbing-n0500-s31415,absorbing,500,31415,structure/classes-warm/consumed,11.341502115061996 +absorbing-n0500-s31415,absorbing,500,31415,structure/irreducible-cold,5.937464521685989 +absorbing-n0500-s31415,absorbing,500,31415,structure/irreducible-warm,23.608345580418167 +absorbing-n1000-s01729,absorbing,1000,1729,construction/public-consumed,10.212161359731184 +absorbing-n1000-s01729,absorbing,1000,1729,evolution/k-10,1.5791915804435857 +absorbing-n1000-s01729,absorbing,1000,1729,evolution/k-100,0.8861036061453018 +absorbing-n1000-s01729,absorbing,1000,1729,evolution/one-step,8.210922585013455 +absorbing-n1000-s01729,absorbing,1000,1729,structure/classes-cold,3.3914552148642927 +absorbing-n1000-s01729,absorbing,1000,1729,structure/classes-lifecycle,6.440866989455148 +absorbing-n1000-s01729,absorbing,1000,1729,structure/classes-warm/access,25.060998235820584 +absorbing-n1000-s01729,absorbing,1000,1729,structure/classes-warm/consumed,11.628062666533586 +absorbing-n1000-s01729,absorbing,1000,1729,structure/irreducible-cold,3.3970948481080114 +absorbing-n1000-s01729,absorbing,1000,1729,structure/irreducible-warm,23.463552022207423 +absorbing-n1000-s02718,absorbing,1000,2718,construction/public-consumed,10.25794672626904 +absorbing-n1000-s02718,absorbing,1000,2718,evolution/k-10,1.5927914596429942 +absorbing-n1000-s02718,absorbing,1000,2718,evolution/k-100,0.887851395498483 +absorbing-n1000-s02718,absorbing,1000,2718,evolution/one-step,8.149753520363927 +absorbing-n1000-s02718,absorbing,1000,2718,structure/classes-cold,3.4235979976065423 +absorbing-n1000-s02718,absorbing,1000,2718,structure/classes-lifecycle,6.4265468880393115 +absorbing-n1000-s02718,absorbing,1000,2718,structure/classes-warm/access,25.000283904749132 +absorbing-n1000-s02718,absorbing,1000,2718,structure/classes-warm/consumed,11.636318145895928 +absorbing-n1000-s02718,absorbing,1000,2718,structure/irreducible-cold,3.4686126708766944 +absorbing-n1000-s02718,absorbing,1000,2718,structure/irreducible-warm,23.351254029787576 +absorbing-n1000-s31415,absorbing,1000,31415,construction/public-consumed,10.500006583681433 +absorbing-n1000-s31415,absorbing,1000,31415,evolution/k-10,2.0411711654113205 +absorbing-n1000-s31415,absorbing,1000,31415,evolution/k-100,1.0812387118169164 +absorbing-n1000-s31415,absorbing,1000,31415,evolution/one-step,11.597469659870328 +absorbing-n1000-s31415,absorbing,1000,31415,structure/classes-cold,3.36241688654659 +absorbing-n1000-s31415,absorbing,1000,31415,structure/classes-lifecycle,5.99535263349096 +absorbing-n1000-s31415,absorbing,1000,31415,structure/classes-warm/access,24.69961619271101 +absorbing-n1000-s31415,absorbing,1000,31415,structure/classes-warm/consumed,11.656454753446233 +absorbing-n1000-s31415,absorbing,1000,31415,structure/irreducible-cold,3.1975561192739117 +absorbing-n1000-s31415,absorbing,1000,31415,structure/irreducible-warm,23.542376102738867 +dense-n0010-s01729,dense,10,1729,construction/public-consumed,66.17863505698352 +dense-n0010-s01729,dense,10,1729,evolution/k-10,32.71277675227978 +dense-n0010-s01729,dense,10,1729,evolution/k-100,83.12117794355001 +dense-n0010-s01729,dense,10,1729,evolution/one-step,145.4341081288183 +dense-n0010-s01729,dense,10,1729,finite-time/n-step/k-10,18.542982908516507 +dense-n0010-s01729,dense,10,1729,finite-time/n-step/k-100,15.195208839332329 +dense-n0010-s01729,dense,10,1729,finite-time/observation/k-10,15.156922194964151 +dense-n0010-s01729,dense,10,1729,finite-time/observation/k-100,14.714296184548873 +dense-n0010-s01729,dense,10,1729,finite-time/step,1.2812692778403292 +dense-n0010-s01729,dense,10,1729,hitting-probability/cold-all-states,2.5636298687413355 +dense-n0010-s01729,dense,10,1729,hitting-time/cold-all-states,5.699890641009064 +dense-n0010-s01729,dense,10,1729,hitting/bounded/at-most/k-10,12.779871672408975 +dense-n0010-s01729,dense,10,1729,hitting/bounded/at-most/k-100,18.84379712134302 +dense-n0010-s01729,dense,10,1729,hitting/bounded/exact/k-10,13.36816270279831 +dense-n0010-s01729,dense,10,1729,hitting/bounded/exact/k-100,19.178942493954334 +dense-n0010-s01729,dense,10,1729,hitting/bounded/greater-than/k-10,12.877592673494043 +dense-n0010-s01729,dense,10,1729,hitting/bounded/greater-than/k-100,17.360735247936173 +dense-n0010-s01729,dense,10,1729,power/10,68.42398572119556 +dense-n0010-s01729,dense,10,1729,power/100,56.81885397973887 +dense-n0010-s01729,dense,10,1729,power/2,94.1927083467718 +dense-n0010-s01729,dense,10,1729,race/forward-committor,14.401325833495191 +dense-n0010-s01729,dense,10,1729,return/bounded/k-10,14.88774465600909 +dense-n0010-s01729,dense,10,1729,return/bounded/k-100,17.600141264442144 +dense-n0010-s01729,dense,10,1729,return/mean-recurrence,35.06729304063153 +dense-n0010-s01729,dense,10,1729,simulation/10000,11.888277527417745 +dense-n0010-s01729,dense,10,1729,simulation/100000,12.206871002035765 +dense-n0010-s01729,dense,10,1729,stationary,11.259924003501267 +dense-n0010-s01729,dense,10,1729,structure/classes-cold,9.965620658094078 +dense-n0010-s01729,dense,10,1729,structure/classes-lifecycle,53.028617306740465 +dense-n0010-s01729,dense,10,1729,structure/classes-warm/access,24.509033956634667 +dense-n0010-s01729,dense,10,1729,structure/classes-warm/consumed,23.924906429721517 +dense-n0010-s01729,dense,10,1729,structure/irreducible-cold,13.09722419823423 +dense-n0010-s01729,dense,10,1729,structure/irreducible-warm,22.988474172991232 +dense-n0010-s01729,dense,10,1729,visits/bounded-expectation/k-10,4.091435674765659 +dense-n0010-s01729,dense,10,1729,visits/bounded-expectation/k-100,2.081309796185928 +dense-n0010-s02718,dense,10,2718,construction/public-consumed,56.05270078089901 +dense-n0010-s02718,dense,10,2718,evolution/k-10,29.27620212365761 +dense-n0010-s02718,dense,10,2718,evolution/k-100,77.34934939802856 +dense-n0010-s02718,dense,10,2718,evolution/one-step,122.44172399900997 +dense-n0010-s02718,dense,10,2718,finite-time/n-step/k-10,19.728119457270978 +dense-n0010-s02718,dense,10,2718,finite-time/n-step/k-100,15.733944109131148 +dense-n0010-s02718,dense,10,2718,finite-time/observation/k-10,16.411006324147817 +dense-n0010-s02718,dense,10,2718,finite-time/observation/k-100,14.955999466888452 +dense-n0010-s02718,dense,10,2718,finite-time/step,1.2574859002486234 +dense-n0010-s02718,dense,10,2718,hitting-probability/cold-all-states,3.0679462649163147 +dense-n0010-s02718,dense,10,2718,hitting-time/cold-all-states,5.66628928357805 +dense-n0010-s02718,dense,10,2718,hitting/bounded/at-most/k-10,14.752056643030132 +dense-n0010-s02718,dense,10,2718,hitting/bounded/at-most/k-100,17.514549490751396 +dense-n0010-s02718,dense,10,2718,hitting/bounded/exact/k-10,15.178327535126511 +dense-n0010-s02718,dense,10,2718,hitting/bounded/exact/k-100,17.73594227436438 +dense-n0010-s02718,dense,10,2718,hitting/bounded/greater-than/k-10,14.940400018242977 +dense-n0010-s02718,dense,10,2718,hitting/bounded/greater-than/k-100,17.120793704518025 +dense-n0010-s02718,dense,10,2718,power/10,66.91318648300805 +dense-n0010-s02718,dense,10,2718,power/100,57.02119497164543 +dense-n0010-s02718,dense,10,2718,power/2,88.6622407407919 +dense-n0010-s02718,dense,10,2718,race/forward-committor,18.062826248354646 +dense-n0010-s02718,dense,10,2718,return/bounded/k-10,15.456953109615304 +dense-n0010-s02718,dense,10,2718,return/bounded/k-100,17.46301876414744 +dense-n0010-s02718,dense,10,2718,return/mean-recurrence,41.05966926605536 +dense-n0010-s02718,dense,10,2718,simulation/10000,12.302792823121909 +dense-n0010-s02718,dense,10,2718,simulation/100000,11.95047546746257 +dense-n0010-s02718,dense,10,2718,stationary,13.152455637376713 +dense-n0010-s02718,dense,10,2718,structure/classes-cold,9.81809909152274 +dense-n0010-s02718,dense,10,2718,structure/classes-lifecycle,50.13993780225354 +dense-n0010-s02718,dense,10,2718,structure/classes-warm/access,25.154183505220203 +dense-n0010-s02718,dense,10,2718,structure/classes-warm/consumed,22.992410058627136 +dense-n0010-s02718,dense,10,2718,structure/irreducible-cold,13.806391364848972 +dense-n0010-s02718,dense,10,2718,structure/irreducible-warm,23.28436557624599 +dense-n0010-s02718,dense,10,2718,visits/bounded-expectation/k-10,4.703013949928501 +dense-n0010-s02718,dense,10,2718,visits/bounded-expectation/k-100,2.0407393117229136 +dense-n0010-s31415,dense,10,31415,construction/public-consumed,59.90966824455504 +dense-n0010-s31415,dense,10,31415,evolution/k-10,29.309195850836364 +dense-n0010-s31415,dense,10,31415,evolution/k-100,80.4138266482201 +dense-n0010-s31415,dense,10,31415,evolution/one-step,118.43669418678417 +dense-n0010-s31415,dense,10,31415,finite-time/n-step/k-10,16.103929232784093 +dense-n0010-s31415,dense,10,31415,finite-time/n-step/k-100,14.36958025372866 +dense-n0010-s31415,dense,10,31415,finite-time/observation/k-10,13.505337251629689 +dense-n0010-s31415,dense,10,31415,finite-time/observation/k-100,13.91011395113641 +dense-n0010-s31415,dense,10,31415,finite-time/step,1.2707891760877528 +dense-n0010-s31415,dense,10,31415,hitting-probability/cold-all-states,2.7160920942664615 +dense-n0010-s31415,dense,10,31415,hitting-time/cold-all-states,6.142474109085361 +dense-n0010-s31415,dense,10,31415,hitting/bounded/at-most/k-10,12.749642735563185 +dense-n0010-s31415,dense,10,31415,hitting/bounded/at-most/k-100,16.50944758426099 +dense-n0010-s31415,dense,10,31415,hitting/bounded/exact/k-10,11.312385966039951 +dense-n0010-s31415,dense,10,31415,hitting/bounded/exact/k-100,17.128130751953975 +dense-n0010-s31415,dense,10,31415,hitting/bounded/greater-than/k-10,12.999125962816132 +dense-n0010-s31415,dense,10,31415,hitting/bounded/greater-than/k-100,16.954029896718886 +dense-n0010-s31415,dense,10,31415,power/10,69.07597709885056 +dense-n0010-s31415,dense,10,31415,power/100,57.33058317013016 +dense-n0010-s31415,dense,10,31415,power/2,86.05061077456737 +dense-n0010-s31415,dense,10,31415,race/forward-committor,16.00184150912272 +dense-n0010-s31415,dense,10,31415,return/bounded/k-10,14.101119924591261 +dense-n0010-s31415,dense,10,31415,return/bounded/k-100,17.602477059647118 +dense-n0010-s31415,dense,10,31415,return/mean-recurrence,35.552830255444164 +dense-n0010-s31415,dense,10,31415,simulation/10000,11.601843636397724 +dense-n0010-s31415,dense,10,31415,simulation/100000,10.470323354604519 +dense-n0010-s31415,dense,10,31415,stationary,12.36356307538299 +dense-n0010-s31415,dense,10,31415,structure/classes-cold,9.955098314516821 +dense-n0010-s31415,dense,10,31415,structure/classes-lifecycle,51.1516541292263 +dense-n0010-s31415,dense,10,31415,structure/classes-warm/access,24.5527717493761 +dense-n0010-s31415,dense,10,31415,structure/classes-warm/consumed,22.493814955700064 +dense-n0010-s31415,dense,10,31415,structure/irreducible-cold,13.303815135878624 +dense-n0010-s31415,dense,10,31415,structure/irreducible-warm,23.001392344867835 +dense-n0010-s31415,dense,10,31415,visits/bounded-expectation/k-10,4.0579212717924955 +dense-n0010-s31415,dense,10,31415,visits/bounded-expectation/k-100,2.0378838854111425 +dense-n0025-s01729,dense,25,1729,construction/public-consumed,28.779972011993536 +dense-n0025-s01729,dense,25,1729,evolution/k-10,31.095382018896807 +dense-n0025-s01729,dense,25,1729,evolution/k-100,29.342239922888275 +dense-n0025-s01729,dense,25,1729,evolution/one-step,116.439043818814 +dense-n0025-s01729,dense,25,1729,finite-time/n-step/k-10,4.508545056094992 +dense-n0025-s01729,dense,25,1729,finite-time/n-step/k-100,2.9001709384633014 +dense-n0025-s01729,dense,25,1729,finite-time/observation/k-10,4.970152148614677 +dense-n0025-s01729,dense,25,1729,finite-time/observation/k-100,11.20033147287451 +dense-n0025-s01729,dense,25,1729,finite-time/step,0.465389877178871 +dense-n0025-s01729,dense,25,1729,hitting-probability/cold-all-states,0.7677094011668764 +dense-n0025-s01729,dense,25,1729,hitting-time/cold-all-states,0.6260354656890889 +dense-n0025-s01729,dense,25,1729,hitting/bounded/at-most/k-10,14.038702205629821 +dense-n0025-s01729,dense,25,1729,hitting/bounded/at-most/k-100,21.8527369267896 +dense-n0025-s01729,dense,25,1729,hitting/bounded/exact/k-10,13.409917829494297 +dense-n0025-s01729,dense,25,1729,hitting/bounded/exact/k-100,20.95431643687135 +dense-n0025-s01729,dense,25,1729,hitting/bounded/greater-than/k-10,14.876781208024275 +dense-n0025-s01729,dense,25,1729,hitting/bounded/greater-than/k-100,21.542673792336192 +dense-n0025-s01729,dense,25,1729,power/10,27.99753893530221 +dense-n0025-s01729,dense,25,1729,power/100,24.092361881190808 +dense-n0025-s01729,dense,25,1729,power/2,42.72294960567668 +dense-n0025-s01729,dense,25,1729,race/forward-committor,4.668514111296473 +dense-n0025-s01729,dense,25,1729,return/bounded/k-10,15.590812448853441 +dense-n0025-s01729,dense,25,1729,return/bounded/k-100,20.32606752427413 +dense-n0025-s01729,dense,25,1729,return/mean-recurrence,39.222640225402024 +dense-n0025-s01729,dense,25,1729,simulation/10000,12.108730414020894 +dense-n0025-s01729,dense,25,1729,simulation/100000,12.687013480099177 +dense-n0025-s01729,dense,25,1729,stationary,6.270367149586344 +dense-n0025-s01729,dense,25,1729,structure/classes-cold,9.115823430432906 +dense-n0025-s01729,dense,25,1729,structure/classes-lifecycle,16.28720397742182 +dense-n0025-s01729,dense,25,1729,structure/classes-warm/access,20.017732764352928 +dense-n0025-s01729,dense,25,1729,structure/classes-warm/consumed,11.552455952316645 +dense-n0025-s01729,dense,25,1729,structure/irreducible-cold,9.910832500315179 +dense-n0025-s01729,dense,25,1729,structure/irreducible-warm,13.56001195199477 +dense-n0025-s01729,dense,25,1729,visits/bounded-expectation/k-10,5.88202377682921 +dense-n0025-s01729,dense,25,1729,visits/bounded-expectation/k-100,2.2257782076074717 +dense-n0025-s02718,dense,25,2718,construction/public-consumed,32.367138447743685 +dense-n0025-s02718,dense,25,2718,evolution/k-10,32.1378943028111 +dense-n0025-s02718,dense,25,2718,evolution/k-100,35.34254718883321 +dense-n0025-s02718,dense,25,2718,evolution/one-step,128.36361449256958 +dense-n0025-s02718,dense,25,2718,finite-time/n-step/k-10,17.49831415215155 +dense-n0025-s02718,dense,25,2718,finite-time/n-step/k-100,3.2320865379959356 +dense-n0025-s02718,dense,25,2718,finite-time/observation/k-10,7.907071713898022 +dense-n0025-s02718,dense,25,2718,finite-time/observation/k-100,13.503390420725127 +dense-n0025-s02718,dense,25,2718,finite-time/step,2.998429242465993 +dense-n0025-s02718,dense,25,2718,hitting-probability/cold-all-states,2.081392819658483 +dense-n0025-s02718,dense,25,2718,hitting-time/cold-all-states,3.9204700317231684 +dense-n0025-s02718,dense,25,2718,hitting/bounded/at-most/k-10,19.196129371727476 +dense-n0025-s02718,dense,25,2718,hitting/bounded/at-most/k-100,21.017490971991904 +dense-n0025-s02718,dense,25,2718,hitting/bounded/exact/k-10,18.57015819129541 +dense-n0025-s02718,dense,25,2718,hitting/bounded/exact/k-100,26.971022468769057 +dense-n0025-s02718,dense,25,2718,hitting/bounded/greater-than/k-10,16.716282912461462 +dense-n0025-s02718,dense,25,2718,hitting/bounded/greater-than/k-100,21.822941675826133 +dense-n0025-s02718,dense,25,2718,power/10,39.051755059804854 +dense-n0025-s02718,dense,25,2718,power/100,27.98209812595762 +dense-n0025-s02718,dense,25,2718,power/2,48.102824639337655 +dense-n0025-s02718,dense,25,2718,race/forward-committor,22.580949642237524 +dense-n0025-s02718,dense,25,2718,return/bounded/k-10,20.86237042180161 +dense-n0025-s02718,dense,25,2718,return/bounded/k-100,18.8365137071295 +dense-n0025-s02718,dense,25,2718,return/mean-recurrence,41.34642750116992 +dense-n0025-s02718,dense,25,2718,simulation/10000,12.074043267590366 +dense-n0025-s02718,dense,25,2718,simulation/100000,10.954687833817264 +dense-n0025-s02718,dense,25,2718,stationary,15.729070718409963 +dense-n0025-s02718,dense,25,2718,structure/classes-cold,11.724567480162541 +dense-n0025-s02718,dense,25,2718,structure/classes-lifecycle,27.398900258494834 +dense-n0025-s02718,dense,25,2718,structure/classes-warm/access,29.062970473667587 +dense-n0025-s02718,dense,25,2718,structure/classes-warm/consumed,22.97907732920259 +dense-n0025-s02718,dense,25,2718,structure/irreducible-cold,21.535239068786574 +dense-n0025-s02718,dense,25,2718,structure/irreducible-warm,28.235218301388002 +dense-n0025-s02718,dense,25,2718,visits/bounded-expectation/k-10,4.657005738604992 +dense-n0025-s02718,dense,25,2718,visits/bounded-expectation/k-100,2.2047386599482306 +dense-n0025-s31415,dense,25,31415,construction/public-consumed,36.71871496678461 +dense-n0025-s31415,dense,25,31415,evolution/k-10,43.999993914166254 +dense-n0025-s31415,dense,25,31415,evolution/k-100,28.904509321756482 +dense-n0025-s31415,dense,25,31415,evolution/one-step,174.04948239492347 +dense-n0025-s31415,dense,25,31415,finite-time/n-step/k-10,23.686064472496533 +dense-n0025-s31415,dense,25,31415,finite-time/n-step/k-100,13.686498993467023 +dense-n0025-s31415,dense,25,31415,finite-time/observation/k-10,20.33278378420255 +dense-n0025-s31415,dense,25,31415,finite-time/observation/k-100,12.91614334900922 +dense-n0025-s31415,dense,25,31415,finite-time/step,3.861282020402908 +dense-n0025-s31415,dense,25,31415,hitting-probability/cold-all-states,1.7529326551882176 +dense-n0025-s31415,dense,25,31415,hitting-time/cold-all-states,4.100519822438418 +dense-n0025-s31415,dense,25,31415,hitting/bounded/at-most/k-10,14.932185144272912 +dense-n0025-s31415,dense,25,31415,hitting/bounded/at-most/k-100,20.129516414430967 +dense-n0025-s31415,dense,25,31415,hitting/bounded/exact/k-10,16.352999114109384 +dense-n0025-s31415,dense,25,31415,hitting/bounded/exact/k-100,19.077187141443744 +dense-n0025-s31415,dense,25,31415,hitting/bounded/greater-than/k-10,16.070167208440008 +dense-n0025-s31415,dense,25,31415,hitting/bounded/greater-than/k-100,19.46622254331408 +dense-n0025-s31415,dense,25,31415,power/10,42.415160736924456 +dense-n0025-s31415,dense,25,31415,power/100,37.16840509423275 +dense-n0025-s31415,dense,25,31415,power/2,49.22218316583519 +dense-n0025-s31415,dense,25,31415,race/forward-committor,21.473527590713672 +dense-n0025-s31415,dense,25,31415,return/bounded/k-10,18.888245254075347 +dense-n0025-s31415,dense,25,31415,return/bounded/k-100,15.913656520405434 +dense-n0025-s31415,dense,25,31415,return/mean-recurrence,41.73446101123269 +dense-n0025-s31415,dense,25,31415,simulation/10000,11.745857155167192 +dense-n0025-s31415,dense,25,31415,simulation/100000,12.058616181090068 +dense-n0025-s31415,dense,25,31415,stationary,13.615192603397947 +dense-n0025-s31415,dense,25,31415,structure/classes-cold,13.990421113689317 +dense-n0025-s31415,dense,25,31415,structure/classes-lifecycle,31.70992260158168 +dense-n0025-s31415,dense,25,31415,structure/classes-warm/access,28.491151745244412 +dense-n0025-s31415,dense,25,31415,structure/classes-warm/consumed,16.949941271181217 +dense-n0025-s31415,dense,25,31415,structure/irreducible-cold,15.064132846033077 +dense-n0025-s31415,dense,25,31415,structure/irreducible-warm,27.108582676570357 +dense-n0025-s31415,dense,25,31415,visits/bounded-expectation/k-10,5.187850287109283 +dense-n0025-s31415,dense,25,31415,visits/bounded-expectation/k-100,2.359595531120969 +dense-n0050-s01729,dense,50,1729,construction/public-consumed,22.551819995100065 +dense-n0050-s01729,dense,50,1729,evolution/k-10,24.240189645384753 +dense-n0050-s01729,dense,50,1729,evolution/k-100,14.865631462856058 +dense-n0050-s01729,dense,50,1729,evolution/one-step,117.94409084830045 +dense-n0050-s01729,dense,50,1729,finite-time/n-step/k-10,18.30272882199298 +dense-n0050-s01729,dense,50,1729,finite-time/n-step/k-100,7.060805146425436 +dense-n0050-s01729,dense,50,1729,finite-time/observation/k-10,14.33859124277515 +dense-n0050-s01729,dense,50,1729,finite-time/observation/k-100,6.930931463025219 +dense-n0050-s01729,dense,50,1729,finite-time/step,4.729138885506494 +dense-n0050-s01729,dense,50,1729,hitting-probability/cold-all-states,1.884108412543613 +dense-n0050-s01729,dense,50,1729,hitting-time/cold-all-states,3.2675619473208486 +dense-n0050-s01729,dense,50,1729,hitting/bounded/at-most/k-10,20.597080955602912 +dense-n0050-s01729,dense,50,1729,hitting/bounded/at-most/k-100,13.848963218697959 +dense-n0050-s01729,dense,50,1729,hitting/bounded/exact/k-10,10.949211788321879 +dense-n0050-s01729,dense,50,1729,hitting/bounded/exact/k-100,15.40948413104204 +dense-n0050-s01729,dense,50,1729,hitting/bounded/greater-than/k-10,13.369622205507792 +dense-n0050-s01729,dense,50,1729,hitting/bounded/greater-than/k-100,14.729093698208409 +dense-n0050-s01729,dense,50,1729,power/10,29.993022806999655 +dense-n0050-s01729,dense,50,1729,power/100,24.394924716238407 +dense-n0050-s01729,dense,50,1729,power/2,33.79709974366411 +dense-n0050-s01729,dense,50,1729,race/forward-committor,20.16511908312735 +dense-n0050-s01729,dense,50,1729,return/bounded/k-10,15.593268271138907 +dense-n0050-s01729,dense,50,1729,return/bounded/k-100,16.202927371253228 +dense-n0050-s01729,dense,50,1729,return/mean-recurrence,28.44861724548921 +dense-n0050-s01729,dense,50,1729,simulation/10000,13.549841456866258 +dense-n0050-s01729,dense,50,1729,simulation/100000,11.760199150313419 +dense-n0050-s01729,dense,50,1729,stationary,8.748806754416545 +dense-n0050-s01729,dense,50,1729,structure/classes-cold,17.36466014547115 +dense-n0050-s01729,dense,50,1729,structure/classes-lifecycle,17.416960722774082 +dense-n0050-s01729,dense,50,1729,structure/classes-warm/access,23.492620423658128 +dense-n0050-s01729,dense,50,1729,structure/classes-warm/consumed,14.541761922856574 +dense-n0050-s01729,dense,50,1729,structure/irreducible-cold,15.33399921769952 +dense-n0050-s01729,dense,50,1729,structure/irreducible-warm,23.702631250465416 +dense-n0050-s01729,dense,50,1729,visits/bounded-expectation/k-10,6.932207079305862 +dense-n0050-s01729,dense,50,1729,visits/bounded-expectation/k-100,2.1420108396568174 +dense-n0050-s02718,dense,50,2718,construction/public-consumed,22.256297718099418 +dense-n0050-s02718,dense,50,2718,evolution/k-10,15.892589307360632 +dense-n0050-s02718,dense,50,2718,evolution/k-100,14.102217526694291 +dense-n0050-s02718,dense,50,2718,evolution/one-step,91.88506897410848 +dense-n0050-s02718,dense,50,2718,finite-time/n-step/k-10,12.467411034090768 +dense-n0050-s02718,dense,50,2718,finite-time/n-step/k-100,6.496499943104623 +dense-n0050-s02718,dense,50,2718,finite-time/observation/k-10,14.114907618470001 +dense-n0050-s02718,dense,50,2718,finite-time/observation/k-100,7.180727085214978 +dense-n0050-s02718,dense,50,2718,finite-time/step,2.9285803127984975 +dense-n0050-s02718,dense,50,2718,hitting-probability/cold-all-states,1.59411989597951 +dense-n0050-s02718,dense,50,2718,hitting-time/cold-all-states,2.537027964137271 +dense-n0050-s02718,dense,50,2718,hitting/bounded/at-most/k-10,14.74786064969561 +dense-n0050-s02718,dense,50,2718,hitting/bounded/at-most/k-100,15.616103127204212 +dense-n0050-s02718,dense,50,2718,hitting/bounded/exact/k-10,14.108307122249233 +dense-n0050-s02718,dense,50,2718,hitting/bounded/exact/k-100,16.666422985566186 +dense-n0050-s02718,dense,50,2718,hitting/bounded/greater-than/k-10,11.32572998858646 +dense-n0050-s02718,dense,50,2718,hitting/bounded/greater-than/k-100,15.018756618821733 +dense-n0050-s02718,dense,50,2718,power/10,27.47521568222871 +dense-n0050-s02718,dense,50,2718,power/100,20.693336473182583 +dense-n0050-s02718,dense,50,2718,power/2,34.711562885129574 +dense-n0050-s02718,dense,50,2718,race/forward-committor,17.399144173941703 +dense-n0050-s02718,dense,50,2718,return/bounded/k-10,14.490260590741293 +dense-n0050-s02718,dense,50,2718,return/bounded/k-100,17.895355133422857 +dense-n0050-s02718,dense,50,2718,return/mean-recurrence,30.227478482793963 +dense-n0050-s02718,dense,50,2718,simulation/10000,13.258610987923833 +dense-n0050-s02718,dense,50,2718,simulation/100000,13.331280752588954 +dense-n0050-s02718,dense,50,2718,stationary,6.981616146269536 +dense-n0050-s02718,dense,50,2718,structure/classes-cold,10.688442059201602 +dense-n0050-s02718,dense,50,2718,structure/classes-lifecycle,19.559066820688443 +dense-n0050-s02718,dense,50,2718,structure/classes-warm/access,19.054744874299065 +dense-n0050-s02718,dense,50,2718,structure/classes-warm/consumed,9.692692840928174 +dense-n0050-s02718,dense,50,2718,structure/irreducible-cold,12.735667902390471 +dense-n0050-s02718,dense,50,2718,structure/irreducible-warm,18.040853848275166 +dense-n0050-s02718,dense,50,2718,visits/bounded-expectation/k-10,7.768769425305298 +dense-n0050-s02718,dense,50,2718,visits/bounded-expectation/k-100,2.3456891011646444 +dense-n0050-s31415,dense,50,31415,construction/public-consumed,24.385129200104995 +dense-n0050-s31415,dense,50,31415,evolution/k-10,21.964137092335793 +dense-n0050-s31415,dense,50,31415,evolution/k-100,16.17977458844679 +dense-n0050-s31415,dense,50,31415,evolution/one-step,107.01302239755135 +dense-n0050-s31415,dense,50,31415,finite-time/n-step/k-10,14.475342265853381 +dense-n0050-s31415,dense,50,31415,finite-time/n-step/k-100,7.548359799447792 +dense-n0050-s31415,dense,50,31415,finite-time/observation/k-10,14.06893556212276 +dense-n0050-s31415,dense,50,31415,finite-time/observation/k-100,7.93370690572066 +dense-n0050-s31415,dense,50,31415,finite-time/step,3.5896487199115508 +dense-n0050-s31415,dense,50,31415,hitting-probability/cold-all-states,1.4495327198353747 +dense-n0050-s31415,dense,50,31415,hitting-time/cold-all-states,2.687263212303513 +dense-n0050-s31415,dense,50,31415,hitting/bounded/at-most/k-10,13.696191796967833 +dense-n0050-s31415,dense,50,31415,hitting/bounded/at-most/k-100,17.467824788443334 +dense-n0050-s31415,dense,50,31415,hitting/bounded/exact/k-10,16.334069770948883 +dense-n0050-s31415,dense,50,31415,hitting/bounded/exact/k-100,16.607771733221895 +dense-n0050-s31415,dense,50,31415,hitting/bounded/greater-than/k-10,14.70098409999935 +dense-n0050-s31415,dense,50,31415,hitting/bounded/greater-than/k-100,17.946519288091658 +dense-n0050-s31415,dense,50,31415,power/10,29.02767734209787 +dense-n0050-s31415,dense,50,31415,power/100,23.16447844294715 +dense-n0050-s31415,dense,50,31415,power/2,44.58450865479955 +dense-n0050-s31415,dense,50,31415,race/forward-committor,19.903500157802586 +dense-n0050-s31415,dense,50,31415,return/bounded/k-10,18.981688394082784 +dense-n0050-s31415,dense,50,31415,return/bounded/k-100,17.653534065113643 +dense-n0050-s31415,dense,50,31415,return/mean-recurrence,29.684530309416132 +dense-n0050-s31415,dense,50,31415,simulation/10000,13.860516808218978 +dense-n0050-s31415,dense,50,31415,simulation/100000,12.145344174593424 +dense-n0050-s31415,dense,50,31415,stationary,8.108431269014426 +dense-n0050-s31415,dense,50,31415,structure/classes-cold,12.022967657157842 +dense-n0050-s31415,dense,50,31415,structure/classes-lifecycle,18.420579198360763 +dense-n0050-s31415,dense,50,31415,structure/classes-warm/access,23.46058299917153 +dense-n0050-s31415,dense,50,31415,structure/classes-warm/consumed,11.852991330185251 +dense-n0050-s31415,dense,50,31415,structure/irreducible-cold,15.78845634505405 +dense-n0050-s31415,dense,50,31415,structure/irreducible-warm,22.91894631678043 +dense-n0050-s31415,dense,50,31415,visits/bounded-expectation/k-10,5.455845875198222 +dense-n0050-s31415,dense,50,31415,visits/bounded-expectation/k-100,2.4361308809689155 +dense-n0100-s01729,dense,100,1729,construction/public-consumed,24.809609610581166 +dense-n0100-s01729,dense,100,1729,evolution/k-10,18.582394989100354 +dense-n0100-s01729,dense,100,1729,evolution/k-100,4.387802370111656 +dense-n0100-s01729,dense,100,1729,evolution/one-step,115.10741280588118 +dense-n0100-s01729,dense,100,1729,finite-time/n-step/k-10,12.630763236391086 +dense-n0100-s01729,dense,100,1729,finite-time/n-step/k-100,4.9278223675611486 +dense-n0100-s01729,dense,100,1729,finite-time/observation/k-10,10.643340056396 +dense-n0100-s01729,dense,100,1729,finite-time/observation/k-100,4.964495352716883 +dense-n0100-s01729,dense,100,1729,finite-time/step,6.964879020852363 +dense-n0100-s01729,dense,100,1729,hitting-probability/cold-all-states,1.7861706683382426 +dense-n0100-s01729,dense,100,1729,hitting-time/cold-all-states,3.4746351451565918 +dense-n0100-s01729,dense,100,1729,hitting/bounded/at-most/k-10,12.448173529546711 +dense-n0100-s01729,dense,100,1729,hitting/bounded/at-most/k-100,14.22725930865152 +dense-n0100-s01729,dense,100,1729,hitting/bounded/exact/k-10,12.612277365088167 +dense-n0100-s01729,dense,100,1729,hitting/bounded/exact/k-100,16.92866495913737 +dense-n0100-s01729,dense,100,1729,hitting/bounded/greater-than/k-10,12.611901081108577 +dense-n0100-s01729,dense,100,1729,hitting/bounded/greater-than/k-100,14.398769219346345 +dense-n0100-s01729,dense,100,1729,power/10,30.919344271962206 +dense-n0100-s01729,dense,100,1729,power/100,26.91999665576896 +dense-n0100-s01729,dense,100,1729,power/2,39.84959843252451 +dense-n0100-s01729,dense,100,1729,race/forward-committor,25.25256584540948 +dense-n0100-s01729,dense,100,1729,return/bounded/k-10,14.347577023310548 +dense-n0100-s01729,dense,100,1729,return/bounded/k-100,16.255184575671706 +dense-n0100-s01729,dense,100,1729,return/mean-recurrence,17.839773826442233 +dense-n0100-s01729,dense,100,1729,simulation/10000,11.873720219751561 +dense-n0100-s01729,dense,100,1729,simulation/100000,12.300802262886883 +dense-n0100-s01729,dense,100,1729,stationary,4.318385845295006 +dense-n0100-s01729,dense,100,1729,structure/classes-cold,13.28000625308507 +dense-n0100-s01729,dense,100,1729,structure/classes-lifecycle,14.889050159742617 +dense-n0100-s01729,dense,100,1729,structure/classes-warm/access,28.288073022680855 +dense-n0100-s01729,dense,100,1729,structure/classes-warm/consumed,13.80774400809582 +dense-n0100-s01729,dense,100,1729,structure/irreducible-cold,15.109356112605068 +dense-n0100-s01729,dense,100,1729,structure/irreducible-warm,22.541901734468556 +dense-n0100-s01729,dense,100,1729,visits/bounded-expectation/k-10,6.018682680287857 +dense-n0100-s01729,dense,100,1729,visits/bounded-expectation/k-100,2.121596342619181 +dense-n0100-s02718,dense,100,2718,construction/public-consumed,18.67471477309493 +dense-n0100-s02718,dense,100,2718,evolution/k-10,10.788163243487647 +dense-n0100-s02718,dense,100,2718,evolution/k-100,3.820734376133158 +dense-n0100-s02718,dense,100,2718,evolution/one-step,55.00181685549441 +dense-n0100-s02718,dense,100,2718,finite-time/n-step/k-10,11.499155243493576 +dense-n0100-s02718,dense,100,2718,finite-time/n-step/k-100,4.543224703007755 +dense-n0100-s02718,dense,100,2718,finite-time/observation/k-10,9.305381894764126 +dense-n0100-s02718,dense,100,2718,finite-time/observation/k-100,4.403157189336328 +dense-n0100-s02718,dense,100,2718,finite-time/step,2.1875788967499097 +dense-n0100-s02718,dense,100,2718,hitting-probability/cold-all-states,1.35795143219061 +dense-n0100-s02718,dense,100,2718,hitting-time/cold-all-states,2.624610697175846 +dense-n0100-s02718,dense,100,2718,hitting/bounded/at-most/k-10,11.585137725285815 +dense-n0100-s02718,dense,100,2718,hitting/bounded/at-most/k-100,16.33628364831153 +dense-n0100-s02718,dense,100,2718,hitting/bounded/exact/k-10,11.642293155909034 +dense-n0100-s02718,dense,100,2718,hitting/bounded/exact/k-100,16.341479752245576 +dense-n0100-s02718,dense,100,2718,hitting/bounded/greater-than/k-10,11.54232175859378 +dense-n0100-s02718,dense,100,2718,hitting/bounded/greater-than/k-100,16.321201056472383 +dense-n0100-s02718,dense,100,2718,power/10,17.824806217127286 +dense-n0100-s02718,dense,100,2718,power/100,16.983891519136176 +dense-n0100-s02718,dense,100,2718,power/2,29.63432923492565 +dense-n0100-s02718,dense,100,2718,race/forward-committor,21.11335651443274 +dense-n0100-s02718,dense,100,2718,return/bounded/k-10,13.935828698132633 +dense-n0100-s02718,dense,100,2718,return/bounded/k-100,16.808015625886483 +dense-n0100-s02718,dense,100,2718,return/mean-recurrence,17.298122170917477 +dense-n0100-s02718,dense,100,2718,simulation/10000,11.870780188341255 +dense-n0100-s02718,dense,100,2718,simulation/100000,12.618694429554987 +dense-n0100-s02718,dense,100,2718,stationary,3.71672472302708 +dense-n0100-s02718,dense,100,2718,structure/classes-cold,9.409283092562612 +dense-n0100-s02718,dense,100,2718,structure/classes-lifecycle,11.51930810163856 +dense-n0100-s02718,dense,100,2718,structure/classes-warm/access,19.89899392257882 +dense-n0100-s02718,dense,100,2718,structure/classes-warm/consumed,9.359494644254497 +dense-n0100-s02718,dense,100,2718,structure/irreducible-cold,10.804856111858543 +dense-n0100-s02718,dense,100,2718,structure/irreducible-warm,19.049289826160944 +dense-n0100-s02718,dense,100,2718,visits/bounded-expectation/k-10,6.312769933362511 +dense-n0100-s02718,dense,100,2718,visits/bounded-expectation/k-100,1.8208342135184827 +dense-n0100-s31415,dense,100,31415,construction/public-consumed,21.797894109199497 +dense-n0100-s31415,dense,100,31415,evolution/k-10,13.81586123635688 +dense-n0100-s31415,dense,100,31415,evolution/k-100,4.679329810244088 +dense-n0100-s31415,dense,100,31415,evolution/one-step,67.33369135991738 +dense-n0100-s31415,dense,100,31415,finite-time/n-step/k-10,11.420515857379858 +dense-n0100-s31415,dense,100,31415,finite-time/n-step/k-100,4.5608137773810205 +dense-n0100-s31415,dense,100,31415,finite-time/observation/k-10,9.55426307626084 +dense-n0100-s31415,dense,100,31415,finite-time/observation/k-100,4.426033021223756 +dense-n0100-s31415,dense,100,31415,finite-time/step,3.477505611907516 +dense-n0100-s31415,dense,100,31415,hitting-probability/cold-all-states,1.7823590826382563 +dense-n0100-s31415,dense,100,31415,hitting-time/cold-all-states,3.638087698740626 +dense-n0100-s31415,dense,100,31415,hitting/bounded/at-most/k-10,11.328670832276961 +dense-n0100-s31415,dense,100,31415,hitting/bounded/at-most/k-100,16.431183864181033 +dense-n0100-s31415,dense,100,31415,hitting/bounded/exact/k-10,11.38084695946587 +dense-n0100-s31415,dense,100,31415,hitting/bounded/exact/k-100,16.293451287608924 +dense-n0100-s31415,dense,100,31415,hitting/bounded/greater-than/k-10,11.548289214240258 +dense-n0100-s31415,dense,100,31415,hitting/bounded/greater-than/k-100,16.370799771456195 +dense-n0100-s31415,dense,100,31415,power/10,28.578904620220705 +dense-n0100-s31415,dense,100,31415,power/100,23.094867908715784 +dense-n0100-s31415,dense,100,31415,power/2,36.30645166054551 +dense-n0100-s31415,dense,100,31415,race/forward-committor,22.720884454800302 +dense-n0100-s31415,dense,100,31415,return/bounded/k-10,14.200115589235752 +dense-n0100-s31415,dense,100,31415,return/bounded/k-100,16.71506929855708 +dense-n0100-s31415,dense,100,31415,return/mean-recurrence,17.30957622964021 +dense-n0100-s31415,dense,100,31415,simulation/10000,11.953433313098206 +dense-n0100-s31415,dense,100,31415,simulation/100000,13.073050238512515 +dense-n0100-s31415,dense,100,31415,stationary,4.603307247441586 +dense-n0100-s31415,dense,100,31415,structure/classes-cold,12.91859414981466 +dense-n0100-s31415,dense,100,31415,structure/classes-lifecycle,16.12704132501124 +dense-n0100-s31415,dense,100,31415,structure/classes-warm/access,25.152736919479096 +dense-n0100-s31415,dense,100,31415,structure/classes-warm/consumed,11.454693659546482 +dense-n0100-s31415,dense,100,31415,structure/irreducible-cold,13.699040398948718 +dense-n0100-s31415,dense,100,31415,structure/irreducible-warm,23.544587130681858 +dense-n0100-s31415,dense,100,31415,visits/bounded-expectation/k-10,6.429807248550153 +dense-n0100-s31415,dense,100,31415,visits/bounded-expectation/k-100,1.8348647526025872 +dense-n0250-s01729,dense,250,1729,construction/public-consumed,15.14708947028119 +dense-n0250-s01729,dense,250,1729,evolution/k-10,5.865777072309861 +dense-n0250-s01729,dense,250,1729,evolution/k-100,1.8875153679109478 +dense-n0250-s01729,dense,250,1729,evolution/one-step,36.70456445251531 +dense-n0250-s01729,dense,250,1729,hitting-probability/cold-all-states,2.7425627443297538 +dense-n0250-s01729,dense,250,1729,hitting-time/cold-all-states,5.25733097720396 +dense-n0250-s01729,dense,250,1729,power/10,25.644815331880178 +dense-n0250-s01729,dense,250,1729,power/100,18.40034806959105 +dense-n0250-s01729,dense,250,1729,power/2,35.6521362605452 +dense-n0250-s01729,dense,250,1729,race/forward-committor,15.399895533327665 +dense-n0250-s01729,dense,250,1729,return/mean-recurrence,7.8795344306396835 +dense-n0250-s01729,dense,250,1729,simulation/10000,9.45609957281466 +dense-n0250-s01729,dense,250,1729,simulation/100000,13.582049515762533 +dense-n0250-s01729,dense,250,1729,stationary,2.4336588691835566 +dense-n0250-s01729,dense,250,1729,structure/classes-cold,11.605258374207438 +dense-n0250-s01729,dense,250,1729,structure/classes-lifecycle,11.043719973890642 +dense-n0250-s01729,dense,250,1729,structure/classes-warm/access,25.248552715299926 +dense-n0250-s01729,dense,250,1729,structure/classes-warm/consumed,10.814172476314777 +dense-n0250-s01729,dense,250,1729,structure/irreducible-cold,11.571915444367919 +dense-n0250-s01729,dense,250,1729,structure/irreducible-warm,22.975906636259154 +dense-n0250-s02718,dense,250,2718,construction/public-consumed,15.863501979524308 +dense-n0250-s02718,dense,250,2718,evolution/k-10,5.583541626454323 +dense-n0250-s02718,dense,250,2718,evolution/k-100,1.8369790141719613 +dense-n0250-s02718,dense,250,2718,evolution/one-step,40.815728184711965 +dense-n0250-s02718,dense,250,2718,hitting-probability/cold-all-states,2.679580062999949 +dense-n0250-s02718,dense,250,2718,hitting-time/cold-all-states,4.627926799434585 +dense-n0250-s02718,dense,250,2718,power/10,25.686281515366243 +dense-n0250-s02718,dense,250,2718,power/100,18.787081702434815 +dense-n0250-s02718,dense,250,2718,power/2,35.809759693896645 +dense-n0250-s02718,dense,250,2718,race/forward-committor,15.290066135694099 +dense-n0250-s02718,dense,250,2718,return/mean-recurrence,7.882727957994314 +dense-n0250-s02718,dense,250,2718,simulation/10000,9.693331421854516 +dense-n0250-s02718,dense,250,2718,simulation/100000,13.551757677031054 +dense-n0250-s02718,dense,250,2718,stationary,2.296783827632259 +dense-n0250-s02718,dense,250,2718,structure/classes-cold,11.838467191759436 +dense-n0250-s02718,dense,250,2718,structure/classes-lifecycle,11.31257352738351 +dense-n0250-s02718,dense,250,2718,structure/classes-warm/access,25.414545949932688 +dense-n0250-s02718,dense,250,2718,structure/classes-warm/consumed,10.820307671004272 +dense-n0250-s02718,dense,250,2718,structure/irreducible-cold,11.773881275330806 +dense-n0250-s02718,dense,250,2718,structure/irreducible-warm,22.794000505410512 +dense-n0250-s31415,dense,250,31415,construction/public-consumed,15.198194548568564 +dense-n0250-s31415,dense,250,31415,evolution/k-10,5.345482490960224 +dense-n0250-s31415,dense,250,31415,evolution/k-100,1.8460016054770851 +dense-n0250-s31415,dense,250,31415,evolution/one-step,34.413355459603096 +dense-n0250-s31415,dense,250,31415,hitting-probability/cold-all-states,2.6735580512260038 +dense-n0250-s31415,dense,250,31415,hitting-time/cold-all-states,5.401023618682491 +dense-n0250-s31415,dense,250,31415,power/10,26.492844579298566 +dense-n0250-s31415,dense,250,31415,power/100,18.76192765491338 +dense-n0250-s31415,dense,250,31415,power/2,36.19017909716977 +dense-n0250-s31415,dense,250,31415,race/forward-committor,15.35130024113588 +dense-n0250-s31415,dense,250,31415,return/mean-recurrence,8.008506284451414 +dense-n0250-s31415,dense,250,31415,simulation/10000,9.478265759190869 +dense-n0250-s31415,dense,250,31415,simulation/100000,13.662912912012436 +dense-n0250-s31415,dense,250,31415,stationary,2.3409336927136577 +dense-n0250-s31415,dense,250,31415,structure/classes-cold,11.572351513503804 +dense-n0250-s31415,dense,250,31415,structure/classes-lifecycle,10.80119846443695 +dense-n0250-s31415,dense,250,31415,structure/classes-warm/access,25.13313326313322 +dense-n0250-s31415,dense,250,31415,structure/classes-warm/consumed,10.835045064256432 +dense-n0250-s31415,dense,250,31415,structure/irreducible-cold,11.711828260037485 +dense-n0250-s31415,dense,250,31415,structure/irreducible-warm,23.117678141210515 +dense-n0500-s01729,dense,500,1729,construction/public-consumed,11.162937253103577 +dense-n0500-s01729,dense,500,1729,evolution/k-10,3.434104648228992 +dense-n0500-s01729,dense,500,1729,evolution/k-100,1.394115420691506 +dense-n0500-s01729,dense,500,1729,evolution/one-step,22.288345072010372 +dense-n0500-s01729,dense,500,1729,hitting-probability/cold-all-states,2.635435488887555 +dense-n0500-s01729,dense,500,1729,hitting-time/cold-all-states,4.933875127112894 +dense-n0500-s01729,dense,500,1729,power/10,18.673996077537037 +dense-n0500-s01729,dense,500,1729,power/100,11.537559927887568 +dense-n0500-s01729,dense,500,1729,power/2,29.138753434376365 +dense-n0500-s01729,dense,500,1729,race/forward-committor,8.604593434863702 +dense-n0500-s01729,dense,500,1729,return/mean-recurrence,3.8793500196712856 +dense-n0500-s01729,dense,500,1729,simulation/10000,5.331549209170485 +dense-n0500-s01729,dense,500,1729,simulation/100000,13.737532901524272 +dense-n0500-s01729,dense,500,1729,stationary,1.489923634937075 +dense-n0500-s01729,dense,500,1729,structure/classes-cold,5.916190635595841 +dense-n0500-s01729,dense,500,1729,structure/classes-lifecycle,7.6050018949330385 +dense-n0500-s01729,dense,500,1729,structure/classes-warm/access,25.055831012560766 +dense-n0500-s01729,dense,500,1729,structure/classes-warm/consumed,11.352983427478701 +dense-n0500-s01729,dense,500,1729,structure/irreducible-cold,5.629773585644551 +dense-n0500-s01729,dense,500,1729,structure/irreducible-warm,23.06919308875645 +dense-n0500-s02718,dense,500,2718,construction/public-consumed,11.33688346993723 +dense-n0500-s02718,dense,500,2718,evolution/k-10,3.472109382823989 +dense-n0500-s02718,dense,500,2718,evolution/k-100,1.4004177419673232 +dense-n0500-s02718,dense,500,2718,evolution/one-step,22.5038203807999 +dense-n0500-s02718,dense,500,2718,hitting-probability/cold-all-states,2.6980070879013702 +dense-n0500-s02718,dense,500,2718,hitting-time/cold-all-states,5.382655776767178 +dense-n0500-s02718,dense,500,2718,power/10,18.458051947911507 +dense-n0500-s02718,dense,500,2718,power/100,11.525460110313624 +dense-n0500-s02718,dense,500,2718,power/2,29.491447342969998 +dense-n0500-s02718,dense,500,2718,race/forward-committor,9.254113457136585 +dense-n0500-s02718,dense,500,2718,return/mean-recurrence,4.2230549658340335 +dense-n0500-s02718,dense,500,2718,simulation/10000,5.377963780619604 +dense-n0500-s02718,dense,500,2718,simulation/100000,13.953555898716107 +dense-n0500-s02718,dense,500,2718,stationary,1.4924432285161513 +dense-n0500-s02718,dense,500,2718,structure/classes-cold,5.98554354180109 +dense-n0500-s02718,dense,500,2718,structure/classes-lifecycle,7.728966676251798 +dense-n0500-s02718,dense,500,2718,structure/classes-warm/access,25.00766583729613 +dense-n0500-s02718,dense,500,2718,structure/classes-warm/consumed,11.37898893181257 +dense-n0500-s02718,dense,500,2718,structure/irreducible-cold,5.867031190717702 +dense-n0500-s02718,dense,500,2718,structure/irreducible-warm,23.248589351377866 +dense-n0500-s31415,dense,500,31415,construction/public-consumed,11.189059665624866 +dense-n0500-s31415,dense,500,31415,evolution/k-10,3.5423392282127826 +dense-n0500-s31415,dense,500,31415,evolution/k-100,1.4046735841054814 +dense-n0500-s31415,dense,500,31415,evolution/one-step,22.55470389537727 +dense-n0500-s31415,dense,500,31415,hitting-probability/cold-all-states,2.61573903184528 +dense-n0500-s31415,dense,500,31415,hitting-time/cold-all-states,5.199102764672115 +dense-n0500-s31415,dense,500,31415,power/10,18.291723118861444 +dense-n0500-s31415,dense,500,31415,power/100,11.572051005400183 +dense-n0500-s31415,dense,500,31415,power/2,28.926068058423837 +dense-n0500-s31415,dense,500,31415,race/forward-committor,9.03881792472649 +dense-n0500-s31415,dense,500,31415,return/mean-recurrence,4.215667175962845 +dense-n0500-s31415,dense,500,31415,simulation/10000,5.2481241915034555 +dense-n0500-s31415,dense,500,31415,simulation/100000,13.57310521976251 +dense-n0500-s31415,dense,500,31415,stationary,1.5281924015780641 +dense-n0500-s31415,dense,500,31415,structure/classes-cold,5.75849647110752 +dense-n0500-s31415,dense,500,31415,structure/classes-lifecycle,7.686801119684506 +dense-n0500-s31415,dense,500,31415,structure/classes-warm/access,25.05843789916199 +dense-n0500-s31415,dense,500,31415,structure/classes-warm/consumed,11.370611839120393 +dense-n0500-s31415,dense,500,31415,structure/irreducible-cold,5.73659310696454 +dense-n0500-s31415,dense,500,31415,structure/irreducible-warm,23.01391357553914 +dense-n1000-s01729,dense,1000,1729,construction/public-consumed,10.006271751723089 +dense-n1000-s01729,dense,1000,1729,evolution/k-10,1.980353388121951 +dense-n1000-s01729,dense,1000,1729,evolution/k-100,1.0758639259788976 +dense-n1000-s01729,dense,1000,1729,evolution/one-step,10.161698546549667 +dense-n1000-s01729,dense,1000,1729,simulation/10000,2.198816914508467 +dense-n1000-s01729,dense,1000,1729,simulation/100000,10.829588136257906 +dense-n1000-s02718,dense,1000,2718,construction/public-consumed,10.004955455754603 +dense-n1000-s02718,dense,1000,2718,evolution/k-10,1.9082937395404789 +dense-n1000-s02718,dense,1000,2718,evolution/k-100,1.060676683954244 +dense-n1000-s02718,dense,1000,2718,evolution/one-step,9.881407898920465 +dense-n1000-s02718,dense,1000,2718,simulation/10000,2.1947945187187217 +dense-n1000-s02718,dense,1000,2718,simulation/100000,10.654820366930096 +dense-n1000-s31415,dense,1000,31415,construction/public-consumed,9.932437509820193 +dense-n1000-s31415,dense,1000,31415,evolution/k-10,1.7634369918690147 +dense-n1000-s31415,dense,1000,31415,evolution/k-100,1.0137951489739232 +dense-n1000-s31415,dense,1000,31415,evolution/one-step,9.62557312066086 +dense-n1000-s31415,dense,1000,31415,simulation/10000,2.2449515651595706 +dense-n1000-s31415,dense,1000,31415,simulation/100000,11.077789594425328 +low-outdegree-n0010-s01729,low-outdegree,10,1729,construction/public-consumed,56.537556720768464 +low-outdegree-n0010-s01729,low-outdegree,10,1729,evolution/k-10,30.861657003412507 +low-outdegree-n0010-s01729,low-outdegree,10,1729,evolution/k-100,84.62743655485485 +low-outdegree-n0010-s01729,low-outdegree,10,1729,evolution/one-step,120.1727520594783 +low-outdegree-n0010-s01729,low-outdegree,10,1729,finite-time/n-step/k-10,17.12881892589997 +low-outdegree-n0010-s01729,low-outdegree,10,1729,finite-time/n-step/k-100,14.917024798256458 +low-outdegree-n0010-s01729,low-outdegree,10,1729,finite-time/observation/k-10,15.039406665803513 +low-outdegree-n0010-s01729,low-outdegree,10,1729,finite-time/observation/k-100,14.395201496962537 +low-outdegree-n0010-s01729,low-outdegree,10,1729,finite-time/step,1.1624204944648735 +low-outdegree-n0010-s01729,low-outdegree,10,1729,hitting-probability/cold-all-states,2.6484359218895763 +low-outdegree-n0010-s01729,low-outdegree,10,1729,hitting-time/cold-all-states,6.132527252667572 +low-outdegree-n0010-s01729,low-outdegree,10,1729,hitting/bounded/at-most/k-10,13.334205051257413 +low-outdegree-n0010-s01729,low-outdegree,10,1729,hitting/bounded/at-most/k-100,18.0366156061381 +low-outdegree-n0010-s01729,low-outdegree,10,1729,hitting/bounded/exact/k-10,13.09675608098966 +low-outdegree-n0010-s01729,low-outdegree,10,1729,hitting/bounded/exact/k-100,17.900305126159513 +low-outdegree-n0010-s01729,low-outdegree,10,1729,hitting/bounded/greater-than/k-10,13.521949304081415 +low-outdegree-n0010-s01729,low-outdegree,10,1729,hitting/bounded/greater-than/k-100,17.89942918802927 +low-outdegree-n0010-s01729,low-outdegree,10,1729,power/10,72.34959455079806 +low-outdegree-n0010-s01729,low-outdegree,10,1729,power/100,56.28748509902592 +low-outdegree-n0010-s01729,low-outdegree,10,1729,power/2,92.36833676048694 +low-outdegree-n0010-s01729,low-outdegree,10,1729,race/forward-committor,14.761216616860652 +low-outdegree-n0010-s01729,low-outdegree,10,1729,return/bounded/k-10,14.560501941894474 +low-outdegree-n0010-s01729,low-outdegree,10,1729,return/bounded/k-100,18.332098901750346 +low-outdegree-n0010-s01729,low-outdegree,10,1729,return/mean-recurrence,36.12049144438705 +low-outdegree-n0010-s01729,low-outdegree,10,1729,simulation/10000,12.846862303953184 +low-outdegree-n0010-s01729,low-outdegree,10,1729,simulation/100000,12.739411777634997 +low-outdegree-n0010-s01729,low-outdegree,10,1729,stationary,11.937614641940119 +low-outdegree-n0010-s01729,low-outdegree,10,1729,structure/classes-cold,7.78503170426378 +low-outdegree-n0010-s01729,low-outdegree,10,1729,structure/classes-lifecycle,48.65792011146012 +low-outdegree-n0010-s01729,low-outdegree,10,1729,structure/classes-warm/access,24.85668214222347 +low-outdegree-n0010-s01729,low-outdegree,10,1729,structure/classes-warm/consumed,22.691025977533222 +low-outdegree-n0010-s01729,low-outdegree,10,1729,structure/irreducible-cold,11.774242021347165 +low-outdegree-n0010-s01729,low-outdegree,10,1729,structure/irreducible-warm,23.410950559197428 +low-outdegree-n0010-s01729,low-outdegree,10,1729,visits/bounded-expectation/k-10,3.8182996466578274 +low-outdegree-n0010-s01729,low-outdegree,10,1729,visits/bounded-expectation/k-100,2.158491552371312 +low-outdegree-n0010-s02718,low-outdegree,10,2718,construction/public-consumed,56.06827245294018 +low-outdegree-n0010-s02718,low-outdegree,10,2718,evolution/k-10,31.065190755205748 +low-outdegree-n0010-s02718,low-outdegree,10,2718,evolution/k-100,84.98661567582434 +low-outdegree-n0010-s02718,low-outdegree,10,2718,evolution/one-step,122.40157768121607 +low-outdegree-n0010-s02718,low-outdegree,10,2718,finite-time/n-step/k-10,16.772227008810557 +low-outdegree-n0010-s02718,low-outdegree,10,2718,finite-time/n-step/k-100,15.025570005603083 +low-outdegree-n0010-s02718,low-outdegree,10,2718,finite-time/observation/k-10,14.774855417373935 +low-outdegree-n0010-s02718,low-outdegree,10,2718,finite-time/observation/k-100,14.323569482887917 +low-outdegree-n0010-s02718,low-outdegree,10,2718,finite-time/step,1.1160813720394982 +low-outdegree-n0010-s02718,low-outdegree,10,2718,hitting-probability/cold-all-states,2.6383611691440776 +low-outdegree-n0010-s02718,low-outdegree,10,2718,hitting-time/cold-all-states,6.131472406878279 +low-outdegree-n0010-s02718,low-outdegree,10,2718,hitting/bounded/at-most/k-10,12.987469614877726 +low-outdegree-n0010-s02718,low-outdegree,10,2718,hitting/bounded/at-most/k-100,17.792717077079963 +low-outdegree-n0010-s02718,low-outdegree,10,2718,hitting/bounded/exact/k-10,12.782193871790474 +low-outdegree-n0010-s02718,low-outdegree,10,2718,hitting/bounded/exact/k-100,17.689058783228433 +low-outdegree-n0010-s02718,low-outdegree,10,2718,hitting/bounded/greater-than/k-10,13.265574199858396 +low-outdegree-n0010-s02718,low-outdegree,10,2718,hitting/bounded/greater-than/k-100,17.850765451082818 +low-outdegree-n0010-s02718,low-outdegree,10,2718,power/10,72.0430068036113 +low-outdegree-n0010-s02718,low-outdegree,10,2718,power/100,56.132120330234414 +low-outdegree-n0010-s02718,low-outdegree,10,2718,power/2,92.06940222641698 +low-outdegree-n0010-s02718,low-outdegree,10,2718,race/forward-committor,14.839580497650429 +low-outdegree-n0010-s02718,low-outdegree,10,2718,return/bounded/k-10,14.242561941446892 +low-outdegree-n0010-s02718,low-outdegree,10,2718,return/bounded/k-100,18.363796021823646 +low-outdegree-n0010-s02718,low-outdegree,10,2718,return/mean-recurrence,36.58915602149434 +low-outdegree-n0010-s02718,low-outdegree,10,2718,simulation/10000,13.031727240217434 +low-outdegree-n0010-s02718,low-outdegree,10,2718,simulation/100000,12.682311959069215 +low-outdegree-n0010-s02718,low-outdegree,10,2718,stationary,12.040057595711279 +low-outdegree-n0010-s02718,low-outdegree,10,2718,structure/classes-cold,7.8278635826476854 +low-outdegree-n0010-s02718,low-outdegree,10,2718,structure/classes-lifecycle,50.155477273808145 +low-outdegree-n0010-s02718,low-outdegree,10,2718,structure/classes-warm/access,25.00721363959326 +low-outdegree-n0010-s02718,low-outdegree,10,2718,structure/classes-warm/consumed,22.887374865324517 +low-outdegree-n0010-s02718,low-outdegree,10,2718,structure/irreducible-cold,11.882723224460168 +low-outdegree-n0010-s02718,low-outdegree,10,2718,structure/irreducible-warm,23.278537354813682 +low-outdegree-n0010-s02718,low-outdegree,10,2718,visits/bounded-expectation/k-10,3.835029542408634 +low-outdegree-n0010-s02718,low-outdegree,10,2718,visits/bounded-expectation/k-100,2.1289518989626535 +low-outdegree-n0010-s31415,low-outdegree,10,31415,construction/public-consumed,56.13684137367999 +low-outdegree-n0010-s31415,low-outdegree,10,31415,evolution/k-10,30.78777150106646 +low-outdegree-n0010-s31415,low-outdegree,10,31415,evolution/k-100,84.37639267136035 +low-outdegree-n0010-s31415,low-outdegree,10,31415,evolution/one-step,123.01953555960536 +low-outdegree-n0010-s31415,low-outdegree,10,31415,finite-time/n-step/k-10,17.214246909516433 +low-outdegree-n0010-s31415,low-outdegree,10,31415,finite-time/n-step/k-100,14.717170671594914 +low-outdegree-n0010-s31415,low-outdegree,10,31415,finite-time/observation/k-10,14.786010462492676 +low-outdegree-n0010-s31415,low-outdegree,10,31415,finite-time/observation/k-100,14.747897723545016 +low-outdegree-n0010-s31415,low-outdegree,10,31415,finite-time/step,1.1447603175628727 +low-outdegree-n0010-s31415,low-outdegree,10,31415,hitting-probability/cold-all-states,2.6540988631107347 +low-outdegree-n0010-s31415,low-outdegree,10,31415,hitting-time/cold-all-states,6.108936116921488 +low-outdegree-n0010-s31415,low-outdegree,10,31415,hitting/bounded/at-most/k-10,13.255175467102267 +low-outdegree-n0010-s31415,low-outdegree,10,31415,hitting/bounded/at-most/k-100,17.79999632215318 +low-outdegree-n0010-s31415,low-outdegree,10,31415,hitting/bounded/exact/k-10,13.377980158279652 +low-outdegree-n0010-s31415,low-outdegree,10,31415,hitting/bounded/exact/k-100,17.663629003406804 +low-outdegree-n0010-s31415,low-outdegree,10,31415,hitting/bounded/greater-than/k-10,13.518813127718726 +low-outdegree-n0010-s31415,low-outdegree,10,31415,hitting/bounded/greater-than/k-100,17.939679430948797 +low-outdegree-n0010-s31415,low-outdegree,10,31415,power/10,71.17551862711619 +low-outdegree-n0010-s31415,low-outdegree,10,31415,power/100,54.544039573266915 +low-outdegree-n0010-s31415,low-outdegree,10,31415,power/2,96.35786434032164 +low-outdegree-n0010-s31415,low-outdegree,10,31415,race/forward-committor,15.020117907669755 +low-outdegree-n0010-s31415,low-outdegree,10,31415,return/bounded/k-10,14.639987538452624 +low-outdegree-n0010-s31415,low-outdegree,10,31415,return/bounded/k-100,18.41899041394601 +low-outdegree-n0010-s31415,low-outdegree,10,31415,return/mean-recurrence,37.11652999462448 +low-outdegree-n0010-s31415,low-outdegree,10,31415,simulation/10000,12.922539166701378 +low-outdegree-n0010-s31415,low-outdegree,10,31415,simulation/100000,12.629713688030968 +low-outdegree-n0010-s31415,low-outdegree,10,31415,stationary,11.847915362985981 +low-outdegree-n0010-s31415,low-outdegree,10,31415,structure/classes-cold,7.8899811213089475 +low-outdegree-n0010-s31415,low-outdegree,10,31415,structure/classes-lifecycle,48.76863496854146 +low-outdegree-n0010-s31415,low-outdegree,10,31415,structure/classes-warm/access,25.4492434015867 +low-outdegree-n0010-s31415,low-outdegree,10,31415,structure/classes-warm/consumed,21.15377353400937 +low-outdegree-n0010-s31415,low-outdegree,10,31415,structure/irreducible-cold,11.963959719047756 +low-outdegree-n0010-s31415,low-outdegree,10,31415,structure/irreducible-warm,22.51257152795361 +low-outdegree-n0010-s31415,low-outdegree,10,31415,visits/bounded-expectation/k-10,3.8339533641270647 +low-outdegree-n0010-s31415,low-outdegree,10,31415,visits/bounded-expectation/k-100,2.125012099535911 +low-outdegree-n0025-s01729,low-outdegree,25,1729,construction/public-consumed,22.61611948346179 +low-outdegree-n0025-s01729,low-outdegree,25,1729,evolution/k-10,27.6443591450246 +low-outdegree-n0025-s01729,low-outdegree,25,1729,evolution/k-100,31.93957905738025 +low-outdegree-n0025-s01729,low-outdegree,25,1729,evolution/one-step,108.73548399592454 +low-outdegree-n0025-s01729,low-outdegree,25,1729,finite-time/n-step/k-10,17.037804907867994 +low-outdegree-n0025-s01729,low-outdegree,25,1729,finite-time/n-step/k-100,11.525396097640607 +low-outdegree-n0025-s01729,low-outdegree,25,1729,finite-time/observation/k-10,13.985068352548028 +low-outdegree-n0025-s01729,low-outdegree,25,1729,finite-time/observation/k-100,11.175491570058663 +low-outdegree-n0025-s01729,low-outdegree,25,1729,finite-time/step,1.4312809678416538 +low-outdegree-n0025-s01729,low-outdegree,25,1729,hitting-probability/cold-all-states,1.812978330336389 +low-outdegree-n0025-s01729,low-outdegree,25,1729,hitting-time/cold-all-states,4.025532161876391 +low-outdegree-n0025-s01729,low-outdegree,25,1729,hitting/bounded/at-most/k-10,13.956692810687374 +low-outdegree-n0025-s01729,low-outdegree,25,1729,hitting/bounded/at-most/k-100,20.316078914470864 +low-outdegree-n0025-s01729,low-outdegree,25,1729,hitting/bounded/exact/k-10,14.524709557603169 +low-outdegree-n0025-s01729,low-outdegree,25,1729,hitting/bounded/exact/k-100,19.84787823401845 +low-outdegree-n0025-s01729,low-outdegree,25,1729,hitting/bounded/greater-than/k-10,14.687973320432947 +low-outdegree-n0025-s01729,low-outdegree,25,1729,hitting/bounded/greater-than/k-100,20.366922334109173 +low-outdegree-n0025-s01729,low-outdegree,25,1729,power/10,34.25704560205878 +low-outdegree-n0025-s01729,low-outdegree,25,1729,power/100,27.811610195109623 +low-outdegree-n0025-s01729,low-outdegree,25,1729,power/2,32.35366481324708 +low-outdegree-n0025-s01729,low-outdegree,25,1729,race/forward-committor,14.879097605577977 +low-outdegree-n0025-s01729,low-outdegree,25,1729,return/bounded/k-10,15.82183661339347 +low-outdegree-n0025-s01729,low-outdegree,25,1729,return/bounded/k-100,20.758030515945162 +low-outdegree-n0025-s01729,low-outdegree,25,1729,return/mean-recurrence,36.72220186136734 +low-outdegree-n0025-s01729,low-outdegree,25,1729,simulation/10000,13.144988218071965 +low-outdegree-n0025-s01729,low-outdegree,25,1729,simulation/100000,12.889497791365427 +low-outdegree-n0025-s01729,low-outdegree,25,1729,stationary,10.62383177639333 +low-outdegree-n0025-s01729,low-outdegree,25,1729,structure/classes-cold,8.622848535788272 +low-outdegree-n0025-s01729,low-outdegree,25,1729,structure/classes-lifecycle,21.591764096984917 +low-outdegree-n0025-s01729,low-outdegree,25,1729,structure/classes-warm/access,25.305347623339046 +low-outdegree-n0025-s01729,low-outdegree,25,1729,structure/classes-warm/consumed,16.274487584179187 +low-outdegree-n0025-s01729,low-outdegree,25,1729,structure/irreducible-cold,14.87542076779683 +low-outdegree-n0025-s01729,low-outdegree,25,1729,structure/irreducible-warm,23.26692963954056 +low-outdegree-n0025-s01729,low-outdegree,25,1729,visits/bounded-expectation/k-10,5.147186373324003 +low-outdegree-n0025-s01729,low-outdegree,25,1729,visits/bounded-expectation/k-100,2.19616755669018 +low-outdegree-n0025-s02718,low-outdegree,25,2718,construction/public-consumed,22.676248167205415 +low-outdegree-n0025-s02718,low-outdegree,25,2718,evolution/k-10,28.502949063690156 +low-outdegree-n0025-s02718,low-outdegree,25,2718,evolution/k-100,32.45572920013099 +low-outdegree-n0025-s02718,low-outdegree,25,2718,evolution/one-step,112.75587394052027 +low-outdegree-n0025-s02718,low-outdegree,25,2718,finite-time/n-step/k-10,16.829588302304188 +low-outdegree-n0025-s02718,low-outdegree,25,2718,finite-time/n-step/k-100,11.755035657621542 +low-outdegree-n0025-s02718,low-outdegree,25,2718,finite-time/observation/k-10,12.299873721917658 +low-outdegree-n0025-s02718,low-outdegree,25,2718,finite-time/observation/k-100,10.796116541200977 +low-outdegree-n0025-s02718,low-outdegree,25,2718,finite-time/step,1.5505432935822918 +low-outdegree-n0025-s02718,low-outdegree,25,2718,hitting-probability/cold-all-states,1.887049642678059 +low-outdegree-n0025-s02718,low-outdegree,25,2718,hitting-time/cold-all-states,4.048125668268196 +low-outdegree-n0025-s02718,low-outdegree,25,2718,hitting/bounded/at-most/k-10,14.511938402161524 +low-outdegree-n0025-s02718,low-outdegree,25,2718,hitting/bounded/at-most/k-100,20.891675953196977 +low-outdegree-n0025-s02718,low-outdegree,25,2718,hitting/bounded/exact/k-10,13.99788294844886 +low-outdegree-n0025-s02718,low-outdegree,25,2718,hitting/bounded/exact/k-100,19.87033228719891 +low-outdegree-n0025-s02718,low-outdegree,25,2718,hitting/bounded/greater-than/k-10,14.572573540498212 +low-outdegree-n0025-s02718,low-outdegree,25,2718,hitting/bounded/greater-than/k-100,19.717691079440165 +low-outdegree-n0025-s02718,low-outdegree,25,2718,power/10,34.1386500407265 +low-outdegree-n0025-s02718,low-outdegree,25,2718,power/100,28.17477583061804 +low-outdegree-n0025-s02718,low-outdegree,25,2718,power/2,32.88298361577893 +low-outdegree-n0025-s02718,low-outdegree,25,2718,race/forward-committor,15.307200282278092 +low-outdegree-n0025-s02718,low-outdegree,25,2718,return/bounded/k-10,15.907029905564777 +low-outdegree-n0025-s02718,low-outdegree,25,2718,return/bounded/k-100,22.645155978069393 +low-outdegree-n0025-s02718,low-outdegree,25,2718,return/mean-recurrence,37.40779117388093 +low-outdegree-n0025-s02718,low-outdegree,25,2718,simulation/10000,12.771597890418642 +low-outdegree-n0025-s02718,low-outdegree,25,2718,simulation/100000,12.71564466279106 +low-outdegree-n0025-s02718,low-outdegree,25,2718,stationary,10.770371909093239 +low-outdegree-n0025-s02718,low-outdegree,25,2718,structure/classes-cold,8.767715778398676 +low-outdegree-n0025-s02718,low-outdegree,25,2718,structure/classes-lifecycle,21.63836446256062 +low-outdegree-n0025-s02718,low-outdegree,25,2718,structure/classes-warm/access,25.377095450921203 +low-outdegree-n0025-s02718,low-outdegree,25,2718,structure/classes-warm/consumed,16.382004401112024 +low-outdegree-n0025-s02718,low-outdegree,25,2718,structure/irreducible-cold,15.206682683077496 +low-outdegree-n0025-s02718,low-outdegree,25,2718,structure/irreducible-warm,23.52095058906709 +low-outdegree-n0025-s02718,low-outdegree,25,2718,visits/bounded-expectation/k-10,5.221614030419226 +low-outdegree-n0025-s02718,low-outdegree,25,2718,visits/bounded-expectation/k-100,2.198724293669152 +low-outdegree-n0025-s31415,low-outdegree,25,31415,construction/public-consumed,22.30851954761737 +low-outdegree-n0025-s31415,low-outdegree,25,31415,evolution/k-10,27.04696792180784 +low-outdegree-n0025-s31415,low-outdegree,25,31415,evolution/k-100,30.96644751356123 +low-outdegree-n0025-s31415,low-outdegree,25,31415,evolution/one-step,111.89801365522914 +low-outdegree-n0025-s31415,low-outdegree,25,31415,finite-time/n-step/k-10,16.765353698865685 +low-outdegree-n0025-s31415,low-outdegree,25,31415,finite-time/n-step/k-100,11.327689558386858 +low-outdegree-n0025-s31415,low-outdegree,25,31415,finite-time/observation/k-10,14.016427977781557 +low-outdegree-n0025-s31415,low-outdegree,25,31415,finite-time/observation/k-100,11.238641355363685 +low-outdegree-n0025-s31415,low-outdegree,25,31415,finite-time/step,1.4960976692089079 +low-outdegree-n0025-s31415,low-outdegree,25,31415,hitting-probability/cold-all-states,1.8372200705508699 +low-outdegree-n0025-s31415,low-outdegree,25,31415,hitting-time/cold-all-states,4.027495522227201 +low-outdegree-n0025-s31415,low-outdegree,25,31415,hitting/bounded/at-most/k-10,13.992271189484512 +low-outdegree-n0025-s31415,low-outdegree,25,31415,hitting/bounded/at-most/k-100,20.11914720383491 +low-outdegree-n0025-s31415,low-outdegree,25,31415,hitting/bounded/exact/k-10,14.442248471984803 +low-outdegree-n0025-s31415,low-outdegree,25,31415,hitting/bounded/exact/k-100,20.1695558233656 +low-outdegree-n0025-s31415,low-outdegree,25,31415,hitting/bounded/greater-than/k-10,15.305884832465255 +low-outdegree-n0025-s31415,low-outdegree,25,31415,hitting/bounded/greater-than/k-100,19.55480979518122 +low-outdegree-n0025-s31415,low-outdegree,25,31415,power/10,32.85149638256804 +low-outdegree-n0025-s31415,low-outdegree,25,31415,power/100,26.623368551257183 +low-outdegree-n0025-s31415,low-outdegree,25,31415,power/2,31.15932637006234 +low-outdegree-n0025-s31415,low-outdegree,25,31415,race/forward-committor,15.488597518677107 +low-outdegree-n0025-s31415,low-outdegree,25,31415,return/bounded/k-10,16.315325686312534 +low-outdegree-n0025-s31415,low-outdegree,25,31415,return/bounded/k-100,19.49528605955601 +low-outdegree-n0025-s31415,low-outdegree,25,31415,return/mean-recurrence,37.453880336030366 +low-outdegree-n0025-s31415,low-outdegree,25,31415,simulation/10000,12.932911250336597 +low-outdegree-n0025-s31415,low-outdegree,25,31415,simulation/100000,12.592285843413684 +low-outdegree-n0025-s31415,low-outdegree,25,31415,stationary,10.582091365194763 +low-outdegree-n0025-s31415,low-outdegree,25,31415,structure/classes-cold,8.961286616435128 +low-outdegree-n0025-s31415,low-outdegree,25,31415,structure/classes-lifecycle,21.595308020090442 +low-outdegree-n0025-s31415,low-outdegree,25,31415,structure/classes-warm/access,23.916344049422296 +low-outdegree-n0025-s31415,low-outdegree,25,31415,structure/classes-warm/consumed,16.205236164182814 +low-outdegree-n0025-s31415,low-outdegree,25,31415,structure/irreducible-cold,15.754560533453256 +low-outdegree-n0025-s31415,low-outdegree,25,31415,structure/irreducible-warm,23.287502304805518 +low-outdegree-n0025-s31415,low-outdegree,25,31415,visits/bounded-expectation/k-10,5.101959517776883 +low-outdegree-n0025-s31415,low-outdegree,25,31415,visits/bounded-expectation/k-100,2.168846681425263 +low-outdegree-n0050-s01729,low-outdegree,50,1729,construction/public-consumed,17.142140565206596 +low-outdegree-n0050-s01729,low-outdegree,50,1729,evolution/k-10,19.23878371974299 +low-outdegree-n0050-s01729,low-outdegree,50,1729,evolution/k-100,14.714777702832809 +low-outdegree-n0050-s01729,low-outdegree,50,1729,evolution/one-step,84.10848713561003 +low-outdegree-n0050-s01729,low-outdegree,50,1729,finite-time/n-step/k-10,14.721778275025425 +low-outdegree-n0050-s01729,low-outdegree,50,1729,finite-time/n-step/k-100,7.144706820058817 +low-outdegree-n0050-s01729,low-outdegree,50,1729,finite-time/observation/k-10,11.57476766626735 +low-outdegree-n0050-s01729,low-outdegree,50,1729,finite-time/observation/k-100,7.02149289051912 +low-outdegree-n0050-s01729,low-outdegree,50,1729,finite-time/step,1.794414132436535 +low-outdegree-n0050-s01729,low-outdegree,50,1729,hitting-probability/cold-all-states,1.729709499584381 +low-outdegree-n0050-s01729,low-outdegree,50,1729,hitting-time/cold-all-states,3.7102947221363105 +low-outdegree-n0050-s01729,low-outdegree,50,1729,hitting/bounded/at-most/k-10,12.903595367687869 +low-outdegree-n0050-s01729,low-outdegree,50,1729,hitting/bounded/at-most/k-100,17.133657304102915 +low-outdegree-n0050-s01729,low-outdegree,50,1729,hitting/bounded/exact/k-10,12.752307450405011 +low-outdegree-n0050-s01729,low-outdegree,50,1729,hitting/bounded/exact/k-100,16.945871154546875 +low-outdegree-n0050-s01729,low-outdegree,50,1729,hitting/bounded/greater-than/k-10,12.835273715280673 +low-outdegree-n0050-s01729,low-outdegree,50,1729,hitting/bounded/greater-than/k-100,16.936058123205648 +low-outdegree-n0050-s01729,low-outdegree,50,1729,power/10,27.933645208451093 +low-outdegree-n0050-s01729,low-outdegree,50,1729,power/100,23.837658392328063 +low-outdegree-n0050-s01729,low-outdegree,50,1729,power/2,17.102926099594722 +low-outdegree-n0050-s01729,low-outdegree,50,1729,race/forward-committor,14.408243475632888 +low-outdegree-n0050-s01729,low-outdegree,50,1729,return/bounded/k-10,14.775741322078742 +low-outdegree-n0050-s01729,low-outdegree,50,1729,return/bounded/k-100,17.422043988260228 +low-outdegree-n0050-s01729,low-outdegree,50,1729,return/mean-recurrence,24.342911991218475 +low-outdegree-n0050-s01729,low-outdegree,50,1729,simulation/10000,13.19487915441665 +low-outdegree-n0050-s01729,low-outdegree,50,1729,simulation/100000,13.41111045424379 +low-outdegree-n0050-s01729,low-outdegree,50,1729,stationary,6.193791807546464 +low-outdegree-n0050-s01729,low-outdegree,50,1729,structure/classes-cold,8.971447343976951 +low-outdegree-n0050-s01729,low-outdegree,50,1729,structure/classes-lifecycle,16.539040080018793 +low-outdegree-n0050-s01729,low-outdegree,50,1729,structure/classes-warm/access,25.267706945708635 +low-outdegree-n0050-s01729,low-outdegree,50,1729,structure/classes-warm/consumed,12.917055257818234 +low-outdegree-n0050-s01729,low-outdegree,50,1729,structure/irreducible-cold,17.715898699008147 +low-outdegree-n0050-s01729,low-outdegree,50,1729,structure/irreducible-warm,22.78227728058502 +low-outdegree-n0050-s01729,low-outdegree,50,1729,visits/bounded-expectation/k-10,6.1969700310777815 +low-outdegree-n0050-s01729,low-outdegree,50,1729,visits/bounded-expectation/k-100,2.01193588458705 +low-outdegree-n0050-s02718,low-outdegree,50,2718,construction/public-consumed,17.209022383872167 +low-outdegree-n0050-s02718,low-outdegree,50,2718,evolution/k-10,19.554351640638277 +low-outdegree-n0050-s02718,low-outdegree,50,2718,evolution/k-100,14.848097992593651 +low-outdegree-n0050-s02718,low-outdegree,50,2718,evolution/one-step,84.06340639806147 +low-outdegree-n0050-s02718,low-outdegree,50,2718,finite-time/n-step/k-10,15.063936264571845 +low-outdegree-n0050-s02718,low-outdegree,50,2718,finite-time/n-step/k-100,7.430328620044407 +low-outdegree-n0050-s02718,low-outdegree,50,2718,finite-time/observation/k-10,11.974816836221148 +low-outdegree-n0050-s02718,low-outdegree,50,2718,finite-time/observation/k-100,7.080055506263443 +low-outdegree-n0050-s02718,low-outdegree,50,2718,finite-time/step,1.8347369899199315 +low-outdegree-n0050-s02718,low-outdegree,50,2718,hitting-probability/cold-all-states,1.7884146555059424 +low-outdegree-n0050-s02718,low-outdegree,50,2718,hitting-time/cold-all-states,3.695152018467581 +low-outdegree-n0050-s02718,low-outdegree,50,2718,hitting/bounded/at-most/k-10,12.884756067586205 +low-outdegree-n0050-s02718,low-outdegree,50,2718,hitting/bounded/at-most/k-100,17.088916162250424 +low-outdegree-n0050-s02718,low-outdegree,50,2718,hitting/bounded/exact/k-10,12.895933275079894 +low-outdegree-n0050-s02718,low-outdegree,50,2718,hitting/bounded/exact/k-100,17.292523474767385 +low-outdegree-n0050-s02718,low-outdegree,50,2718,hitting/bounded/greater-than/k-10,12.91292157590576 +low-outdegree-n0050-s02718,low-outdegree,50,2718,hitting/bounded/greater-than/k-100,16.910748619043325 +low-outdegree-n0050-s02718,low-outdegree,50,2718,power/10,28.131191336568506 +low-outdegree-n0050-s02718,low-outdegree,50,2718,power/100,24.41240801310449 +low-outdegree-n0050-s02718,low-outdegree,50,2718,power/2,17.635299889810195 +low-outdegree-n0050-s02718,low-outdegree,50,2718,race/forward-committor,14.72226677039441 +low-outdegree-n0050-s02718,low-outdegree,50,2718,return/bounded/k-10,14.743943187242458 +low-outdegree-n0050-s02718,low-outdegree,50,2718,return/bounded/k-100,17.55233791047442 +low-outdegree-n0050-s02718,low-outdegree,50,2718,return/mean-recurrence,24.35495317207047 +low-outdegree-n0050-s02718,low-outdegree,50,2718,simulation/10000,13.312453580999275 +low-outdegree-n0050-s02718,low-outdegree,50,2718,simulation/100000,13.1523758397122 +low-outdegree-n0050-s02718,low-outdegree,50,2718,stationary,6.3606234447067465 +low-outdegree-n0050-s02718,low-outdegree,50,2718,structure/classes-cold,8.964987628640621 +low-outdegree-n0050-s02718,low-outdegree,50,2718,structure/classes-lifecycle,16.905737244434416 +low-outdegree-n0050-s02718,low-outdegree,50,2718,structure/classes-warm/access,25.29001113676059 +low-outdegree-n0050-s02718,low-outdegree,50,2718,structure/classes-warm/consumed,12.878601810310522 +low-outdegree-n0050-s02718,low-outdegree,50,2718,structure/irreducible-cold,18.089088916231162 +low-outdegree-n0050-s02718,low-outdegree,50,2718,structure/irreducible-warm,23.402550450533436 +low-outdegree-n0050-s02718,low-outdegree,50,2718,visits/bounded-expectation/k-10,6.2599011652187375 +low-outdegree-n0050-s02718,low-outdegree,50,2718,visits/bounded-expectation/k-100,2.017585189240143 +low-outdegree-n0050-s31415,low-outdegree,50,31415,construction/public-consumed,17.266884247979284 +low-outdegree-n0050-s31415,low-outdegree,50,31415,evolution/k-10,20.10504929658738 +low-outdegree-n0050-s31415,low-outdegree,50,31415,evolution/k-100,15.33002744013193 +low-outdegree-n0050-s31415,low-outdegree,50,31415,evolution/one-step,84.61297090095998 +low-outdegree-n0050-s31415,low-outdegree,50,31415,finite-time/n-step/k-10,14.87944506649417 +low-outdegree-n0050-s31415,low-outdegree,50,31415,finite-time/n-step/k-100,7.378605744639573 +low-outdegree-n0050-s31415,low-outdegree,50,31415,finite-time/observation/k-10,12.03322746669477 +low-outdegree-n0050-s31415,low-outdegree,50,31415,finite-time/observation/k-100,7.055404916046318 +low-outdegree-n0050-s31415,low-outdegree,50,31415,finite-time/step,1.7816761102605758 +low-outdegree-n0050-s31415,low-outdegree,50,31415,hitting-probability/cold-all-states,1.7648286142362362 +low-outdegree-n0050-s31415,low-outdegree,50,31415,hitting-time/cold-all-states,3.715731795649829 +low-outdegree-n0050-s31415,low-outdegree,50,31415,hitting/bounded/at-most/k-10,12.907033189701753 +low-outdegree-n0050-s31415,low-outdegree,50,31415,hitting/bounded/at-most/k-100,17.39714505497244 +low-outdegree-n0050-s31415,low-outdegree,50,31415,hitting/bounded/exact/k-10,12.69200274297819 +low-outdegree-n0050-s31415,low-outdegree,50,31415,hitting/bounded/exact/k-100,17.028913672419197 +low-outdegree-n0050-s31415,low-outdegree,50,31415,hitting/bounded/greater-than/k-10,12.98930152226001 +low-outdegree-n0050-s31415,low-outdegree,50,31415,hitting/bounded/greater-than/k-100,17.298472344946433 +low-outdegree-n0050-s31415,low-outdegree,50,31415,power/10,29.18714518202023 +low-outdegree-n0050-s31415,low-outdegree,50,31415,power/100,24.68815438620066 +low-outdegree-n0050-s31415,low-outdegree,50,31415,power/2,17.54558073200088 +low-outdegree-n0050-s31415,low-outdegree,50,31415,race/forward-committor,14.610771677616576 +low-outdegree-n0050-s31415,low-outdegree,50,31415,return/bounded/k-10,14.763498849484225 +low-outdegree-n0050-s31415,low-outdegree,50,31415,return/bounded/k-100,17.35601469433715 +low-outdegree-n0050-s31415,low-outdegree,50,31415,return/mean-recurrence,24.561953364368954 +low-outdegree-n0050-s31415,low-outdegree,50,31415,simulation/10000,13.007243387080281 +low-outdegree-n0050-s31415,low-outdegree,50,31415,simulation/100000,12.883186096762483 +low-outdegree-n0050-s31415,low-outdegree,50,31415,stationary,6.419707974083878 +low-outdegree-n0050-s31415,low-outdegree,50,31415,structure/classes-cold,9.030511650323495 +low-outdegree-n0050-s31415,low-outdegree,50,31415,structure/classes-lifecycle,16.835243241099633 +low-outdegree-n0050-s31415,low-outdegree,50,31415,structure/classes-warm/access,25.250582607523366 +low-outdegree-n0050-s31415,low-outdegree,50,31415,structure/classes-warm/consumed,12.846136741371605 +low-outdegree-n0050-s31415,low-outdegree,50,31415,structure/irreducible-cold,18.25388987232624 +low-outdegree-n0050-s31415,low-outdegree,50,31415,structure/irreducible-warm,23.691786534328692 +low-outdegree-n0050-s31415,low-outdegree,50,31415,visits/bounded-expectation/k-10,6.180964276235256 +low-outdegree-n0050-s31415,low-outdegree,50,31415,visits/bounded-expectation/k-100,2.030114311264699 +low-outdegree-n0100-s01729,low-outdegree,100,1729,construction/public-consumed,15.539103828128324 +low-outdegree-n0100-s01729,low-outdegree,100,1729,evolution/k-10,13.4925665518366 +low-outdegree-n0100-s01729,low-outdegree,100,1729,evolution/k-100,4.600532454313634 +low-outdegree-n0100-s01729,low-outdegree,100,1729,evolution/one-step,65.6064281871148 +low-outdegree-n0100-s01729,low-outdegree,100,1729,finite-time/n-step/k-10,11.525927631282833 +low-outdegree-n0100-s01729,low-outdegree,100,1729,finite-time/n-step/k-100,4.451691023576952 +low-outdegree-n0100-s01729,low-outdegree,100,1729,finite-time/observation/k-10,9.352667323093534 +low-outdegree-n0100-s01729,low-outdegree,100,1729,finite-time/observation/k-100,4.380643485079838 +low-outdegree-n0100-s01729,low-outdegree,100,1729,finite-time/step,3.184745668899098 +low-outdegree-n0100-s01729,low-outdegree,100,1729,hitting-probability/cold-all-states,2.611813484136657 +low-outdegree-n0100-s01729,low-outdegree,100,1729,hitting-time/cold-all-states,5.3293101707037716 +low-outdegree-n0100-s01729,low-outdegree,100,1729,hitting/bounded/at-most/k-10,11.4408553958528 +low-outdegree-n0100-s01729,low-outdegree,100,1729,hitting/bounded/at-most/k-100,16.281606280123945 +low-outdegree-n0100-s01729,low-outdegree,100,1729,hitting/bounded/exact/k-10,11.462099055761112 +low-outdegree-n0100-s01729,low-outdegree,100,1729,hitting/bounded/exact/k-100,16.21960657899076 +low-outdegree-n0100-s01729,low-outdegree,100,1729,hitting/bounded/greater-than/k-10,11.419629144594683 +low-outdegree-n0100-s01729,low-outdegree,100,1729,hitting/bounded/greater-than/k-100,16.368079739327747 +low-outdegree-n0100-s01729,low-outdegree,100,1729,power/10,28.647524870551564 +low-outdegree-n0100-s01729,low-outdegree,100,1729,power/100,22.76013801096641 +low-outdegree-n0100-s01729,low-outdegree,100,1729,power/2,11.920678473288874 +low-outdegree-n0100-s01729,low-outdegree,100,1729,race/forward-committor,15.646492444543496 +low-outdegree-n0100-s01729,low-outdegree,100,1729,return/bounded/k-10,14.280039009759856 +low-outdegree-n0100-s01729,low-outdegree,100,1729,return/bounded/k-100,16.844579440580368 +low-outdegree-n0100-s01729,low-outdegree,100,1729,return/mean-recurrence,11.494611310718946 +low-outdegree-n0100-s01729,low-outdegree,100,1729,simulation/10000,13.883727928501026 +low-outdegree-n0100-s01729,low-outdegree,100,1729,simulation/100000,13.875383314998306 +low-outdegree-n0100-s01729,low-outdegree,100,1729,stationary,2.7464359845231003 +low-outdegree-n0100-s01729,low-outdegree,100,1729,structure/classes-cold,10.507476574529784 +low-outdegree-n0100-s01729,low-outdegree,100,1729,structure/classes-lifecycle,15.188868909928312 +low-outdegree-n0100-s01729,low-outdegree,100,1729,structure/classes-warm/access,24.928298721193975 +low-outdegree-n0100-s01729,low-outdegree,100,1729,structure/classes-warm/consumed,11.46627405978543 +low-outdegree-n0100-s01729,low-outdegree,100,1729,structure/irreducible-cold,21.61111333615895 +low-outdegree-n0100-s01729,low-outdegree,100,1729,structure/irreducible-warm,23.460750422262475 +low-outdegree-n0100-s01729,low-outdegree,100,1729,visits/bounded-expectation/k-10,6.256910276932357 +low-outdegree-n0100-s01729,low-outdegree,100,1729,visits/bounded-expectation/k-100,1.7917684845100048 +low-outdegree-n0100-s02718,low-outdegree,100,2718,construction/public-consumed,15.269474123194703 +low-outdegree-n0100-s02718,low-outdegree,100,2718,evolution/k-10,13.505654570807762 +low-outdegree-n0100-s02718,low-outdegree,100,2718,evolution/k-100,4.600313629728785 +low-outdegree-n0100-s02718,low-outdegree,100,2718,evolution/one-step,65.10744402752589 +low-outdegree-n0100-s02718,low-outdegree,100,2718,finite-time/n-step/k-10,11.391650329931931 +low-outdegree-n0100-s02718,low-outdegree,100,2718,finite-time/n-step/k-100,4.417569951049268 +low-outdegree-n0100-s02718,low-outdegree,100,2718,finite-time/observation/k-10,9.345777436213535 +low-outdegree-n0100-s02718,low-outdegree,100,2718,finite-time/observation/k-100,4.3729782476901295 +low-outdegree-n0100-s02718,low-outdegree,100,2718,finite-time/step,3.1799296990531083 +low-outdegree-n0100-s02718,low-outdegree,100,2718,hitting-probability/cold-all-states,2.569427109699544 +low-outdegree-n0100-s02718,low-outdegree,100,2718,hitting-time/cold-all-states,5.122044868377009 +low-outdegree-n0100-s02718,low-outdegree,100,2718,hitting/bounded/at-most/k-10,11.52400912557531 +low-outdegree-n0100-s02718,low-outdegree,100,2718,hitting/bounded/at-most/k-100,16.35058592465053 +low-outdegree-n0100-s02718,low-outdegree,100,2718,hitting/bounded/exact/k-10,11.382647996329823 +low-outdegree-n0100-s02718,low-outdegree,100,2718,hitting/bounded/exact/k-100,16.435092196529077 +low-outdegree-n0100-s02718,low-outdegree,100,2718,hitting/bounded/greater-than/k-10,11.44375980949118 +low-outdegree-n0100-s02718,low-outdegree,100,2718,hitting/bounded/greater-than/k-100,16.355478370895938 +low-outdegree-n0100-s02718,low-outdegree,100,2718,power/10,28.776353264363323 +low-outdegree-n0100-s02718,low-outdegree,100,2718,power/100,21.264819548849093 +low-outdegree-n0100-s02718,low-outdegree,100,2718,power/2,11.9024290758836 +low-outdegree-n0100-s02718,low-outdegree,100,2718,race/forward-committor,15.713988231688841 +low-outdegree-n0100-s02718,low-outdegree,100,2718,return/bounded/k-10,14.276528039533913 +low-outdegree-n0100-s02718,low-outdegree,100,2718,return/bounded/k-100,16.65638757429495 +low-outdegree-n0100-s02718,low-outdegree,100,2718,return/mean-recurrence,11.551763073429433 +low-outdegree-n0100-s02718,low-outdegree,100,2718,simulation/10000,13.81282703357203 +low-outdegree-n0100-s02718,low-outdegree,100,2718,simulation/100000,13.734862792743396 +low-outdegree-n0100-s02718,low-outdegree,100,2718,stationary,2.7346458509489997 +low-outdegree-n0100-s02718,low-outdegree,100,2718,structure/classes-cold,9.938926223745613 +low-outdegree-n0100-s02718,low-outdegree,100,2718,structure/classes-lifecycle,14.945512977363052 +low-outdegree-n0100-s02718,low-outdegree,100,2718,structure/classes-warm/access,25.122622460532963 +low-outdegree-n0100-s02718,low-outdegree,100,2718,structure/classes-warm/consumed,11.107372391044002 +low-outdegree-n0100-s02718,low-outdegree,100,2718,structure/irreducible-cold,21.68694239669916 +low-outdegree-n0100-s02718,low-outdegree,100,2718,structure/irreducible-warm,23.545664557248017 +low-outdegree-n0100-s02718,low-outdegree,100,2718,visits/bounded-expectation/k-10,6.1860613713668435 +low-outdegree-n0100-s02718,low-outdegree,100,2718,visits/bounded-expectation/k-100,1.790285291524837 +low-outdegree-n0100-s31415,low-outdegree,100,31415,construction/public-consumed,15.5235758356998 +low-outdegree-n0100-s31415,low-outdegree,100,31415,evolution/k-10,13.39470681717413 +low-outdegree-n0100-s31415,low-outdegree,100,31415,evolution/k-100,4.614753458041963 +low-outdegree-n0100-s31415,low-outdegree,100,31415,evolution/one-step,66.06023557108676 +low-outdegree-n0100-s31415,low-outdegree,100,31415,finite-time/n-step/k-10,11.332274550658903 +low-outdegree-n0100-s31415,low-outdegree,100,31415,finite-time/n-step/k-100,4.499474576865877 +low-outdegree-n0100-s31415,low-outdegree,100,31415,finite-time/observation/k-10,9.36975366413695 +low-outdegree-n0100-s31415,low-outdegree,100,31415,finite-time/observation/k-100,4.361097064802975 +low-outdegree-n0100-s31415,low-outdegree,100,31415,finite-time/step,3.187363922768538 +low-outdegree-n0100-s31415,low-outdegree,100,31415,hitting-probability/cold-all-states,2.5980467188964473 +low-outdegree-n0100-s31415,low-outdegree,100,31415,hitting-time/cold-all-states,5.25408072489465 +low-outdegree-n0100-s31415,low-outdegree,100,31415,hitting/bounded/at-most/k-10,11.368803263208738 +low-outdegree-n0100-s31415,low-outdegree,100,31415,hitting/bounded/at-most/k-100,16.35709607357542 +low-outdegree-n0100-s31415,low-outdegree,100,31415,hitting/bounded/exact/k-10,11.432727593092737 +low-outdegree-n0100-s31415,low-outdegree,100,31415,hitting/bounded/exact/k-100,16.339275969655787 +low-outdegree-n0100-s31415,low-outdegree,100,31415,hitting/bounded/greater-than/k-10,11.414997217366366 +low-outdegree-n0100-s31415,low-outdegree,100,31415,hitting/bounded/greater-than/k-100,16.317295698485548 +low-outdegree-n0100-s31415,low-outdegree,100,31415,power/10,28.34518190921752 +low-outdegree-n0100-s31415,low-outdegree,100,31415,power/100,22.99343507177215 +low-outdegree-n0100-s31415,low-outdegree,100,31415,power/2,11.92578913161752 +low-outdegree-n0100-s31415,low-outdegree,100,31415,race/forward-committor,15.55909113809596 +low-outdegree-n0100-s31415,low-outdegree,100,31415,return/bounded/k-10,14.203320175214039 +low-outdegree-n0100-s31415,low-outdegree,100,31415,return/bounded/k-100,16.799346424379376 +low-outdegree-n0100-s31415,low-outdegree,100,31415,return/mean-recurrence,12.379474189365235 +low-outdegree-n0100-s31415,low-outdegree,100,31415,simulation/10000,13.728049180609599 +low-outdegree-n0100-s31415,low-outdegree,100,31415,simulation/100000,14.083296475998884 +low-outdegree-n0100-s31415,low-outdegree,100,31415,stationary,2.7679403123331916 +low-outdegree-n0100-s31415,low-outdegree,100,31415,structure/classes-cold,10.13717188807615 +low-outdegree-n0100-s31415,low-outdegree,100,31415,structure/classes-lifecycle,15.162061122920866 +low-outdegree-n0100-s31415,low-outdegree,100,31415,structure/classes-warm/access,25.4032534265548 +low-outdegree-n0100-s31415,low-outdegree,100,31415,structure/classes-warm/consumed,11.508859020790702 +low-outdegree-n0100-s31415,low-outdegree,100,31415,structure/irreducible-cold,21.921672004488553 +low-outdegree-n0100-s31415,low-outdegree,100,31415,structure/irreducible-warm,23.276060080220425 +low-outdegree-n0100-s31415,low-outdegree,100,31415,visits/bounded-expectation/k-10,6.231200028668649 +low-outdegree-n0100-s31415,low-outdegree,100,31415,visits/bounded-expectation/k-100,1.7942060669286326 +low-outdegree-n0250-s01729,low-outdegree,250,1729,construction/public-consumed,10.582055056634086 +low-outdegree-n0250-s01729,low-outdegree,250,1729,evolution/k-10,4.357892548596855 +low-outdegree-n0250-s01729,low-outdegree,250,1729,evolution/k-100,1.667487276559086 +low-outdegree-n0250-s01729,low-outdegree,250,1729,evolution/one-step,26.194914665026115 +low-outdegree-n0250-s01729,low-outdegree,250,1729,hitting-probability/cold-all-states,5.990103791090945 +low-outdegree-n0250-s01729,low-outdegree,250,1729,hitting-time/cold-all-states,11.860874312169589 +low-outdegree-n0250-s01729,low-outdegree,250,1729,power/10,25.48841402541164 +low-outdegree-n0250-s01729,low-outdegree,250,1729,power/100,18.31149677127459 +low-outdegree-n0250-s01729,low-outdegree,250,1729,power/2,7.947928475958428 +low-outdegree-n0250-s01729,low-outdegree,250,1729,race/forward-committor,15.73103335606123 +low-outdegree-n0250-s01729,low-outdegree,250,1729,return/mean-recurrence,4.117076672071023 +low-outdegree-n0250-s01729,low-outdegree,250,1729,simulation/10000,15.544703136485698 +low-outdegree-n0250-s01729,low-outdegree,250,1729,simulation/100000,15.692094984054666 +low-outdegree-n0250-s01729,low-outdegree,250,1729,stationary,1.1924105092190016 +low-outdegree-n0250-s01729,low-outdegree,250,1729,structure/classes-cold,10.834645058661504 +low-outdegree-n0250-s01729,low-outdegree,250,1729,structure/classes-lifecycle,10.385031160371836 +low-outdegree-n0250-s01729,low-outdegree,250,1729,structure/classes-warm/access,25.16994701287154 +low-outdegree-n0250-s01729,low-outdegree,250,1729,structure/classes-warm/consumed,10.733176106619243 +low-outdegree-n0250-s01729,low-outdegree,250,1729,structure/irreducible-cold,24.99218442703548 +low-outdegree-n0250-s01729,low-outdegree,250,1729,structure/irreducible-warm,23.192802727645674 +low-outdegree-n0250-s02718,low-outdegree,250,2718,construction/public-consumed,10.455368209974795 +low-outdegree-n0250-s02718,low-outdegree,250,2718,evolution/k-10,4.342289169726232 +low-outdegree-n0250-s02718,low-outdegree,250,2718,evolution/k-100,1.6778788247659162 +low-outdegree-n0250-s02718,low-outdegree,250,2718,evolution/one-step,26.335425912200453 +low-outdegree-n0250-s02718,low-outdegree,250,2718,hitting-probability/cold-all-states,6.001438666802655 +low-outdegree-n0250-s02718,low-outdegree,250,2718,hitting-time/cold-all-states,11.906425595083302 +low-outdegree-n0250-s02718,low-outdegree,250,2718,power/10,25.237236207389405 +low-outdegree-n0250-s02718,low-outdegree,250,2718,power/100,18.546494210083928 +low-outdegree-n0250-s02718,low-outdegree,250,2718,power/2,7.878088888216936 +low-outdegree-n0250-s02718,low-outdegree,250,2718,race/forward-committor,15.946701107417544 +low-outdegree-n0250-s02718,low-outdegree,250,2718,return/mean-recurrence,4.126899857315318 +low-outdegree-n0250-s02718,low-outdegree,250,2718,simulation/10000,15.536923545483685 +low-outdegree-n0250-s02718,low-outdegree,250,2718,simulation/100000,15.772931568780967 +low-outdegree-n0250-s02718,low-outdegree,250,2718,stationary,1.1920752462943485 +low-outdegree-n0250-s02718,low-outdegree,250,2718,structure/classes-cold,11.224131967896737 +low-outdegree-n0250-s02718,low-outdegree,250,2718,structure/classes-lifecycle,10.38468489090598 +low-outdegree-n0250-s02718,low-outdegree,250,2718,structure/classes-warm/access,25.237182752616917 +low-outdegree-n0250-s02718,low-outdegree,250,2718,structure/classes-warm/consumed,10.807842669239724 +low-outdegree-n0250-s02718,low-outdegree,250,2718,structure/irreducible-cold,25.46874246667692 +low-outdegree-n0250-s02718,low-outdegree,250,2718,structure/irreducible-warm,23.31385535693385 +low-outdegree-n0250-s31415,low-outdegree,250,31415,construction/public-consumed,10.490802296603235 +low-outdegree-n0250-s31415,low-outdegree,250,31415,evolution/k-10,4.349168999275953 +low-outdegree-n0250-s31415,low-outdegree,250,31415,evolution/k-100,1.6796346757365663 +low-outdegree-n0250-s31415,low-outdegree,250,31415,evolution/one-step,26.248827299000013 +low-outdegree-n0250-s31415,low-outdegree,250,31415,hitting-probability/cold-all-states,5.96265308600829 +low-outdegree-n0250-s31415,low-outdegree,250,31415,hitting-time/cold-all-states,11.813901078489005 +low-outdegree-n0250-s31415,low-outdegree,250,31415,power/10,25.1322635761724 +low-outdegree-n0250-s31415,low-outdegree,250,31415,power/100,18.797192489481706 +low-outdegree-n0250-s31415,low-outdegree,250,31415,power/2,8.00610727099782 +low-outdegree-n0250-s31415,low-outdegree,250,31415,race/forward-committor,16.028943837236202 +low-outdegree-n0250-s31415,low-outdegree,250,31415,return/mean-recurrence,4.204148476571489 +low-outdegree-n0250-s31415,low-outdegree,250,31415,simulation/10000,15.331313916195175 +low-outdegree-n0250-s31415,low-outdegree,250,31415,simulation/100000,15.783059223529222 +low-outdegree-n0250-s31415,low-outdegree,250,31415,stationary,1.2041684137646034 +low-outdegree-n0250-s31415,low-outdegree,250,31415,structure/classes-cold,11.22776169716079 +low-outdegree-n0250-s31415,low-outdegree,250,31415,structure/classes-lifecycle,10.509236412931882 +low-outdegree-n0250-s31415,low-outdegree,250,31415,structure/classes-warm/access,25.214137899236093 +low-outdegree-n0250-s31415,low-outdegree,250,31415,structure/classes-warm/consumed,10.658455838514024 +low-outdegree-n0250-s31415,low-outdegree,250,31415,structure/irreducible-cold,25.202396504470876 +low-outdegree-n0250-s31415,low-outdegree,250,31415,structure/irreducible-warm,23.425048975725424 +low-outdegree-n0500-s01729,low-outdegree,500,1729,construction/public-consumed,7.703590028828562 +low-outdegree-n0500-s01729,low-outdegree,500,1729,evolution/k-10,3.314922962142458 +low-outdegree-n0500-s01729,low-outdegree,500,1729,evolution/k-100,1.3798620239298023 +low-outdegree-n0500-s01729,low-outdegree,500,1729,evolution/one-step,21.192195400105657 +low-outdegree-n0500-s01729,low-outdegree,500,1729,hitting-probability/cold-all-states,6.3946956461468405 +low-outdegree-n0500-s01729,low-outdegree,500,1729,hitting-time/cold-all-states,12.465341581030176 +low-outdegree-n0500-s01729,low-outdegree,500,1729,power/10,18.108332302366257 +low-outdegree-n0500-s01729,low-outdegree,500,1729,power/100,11.201913200664306 +low-outdegree-n0500-s01729,low-outdegree,500,1729,power/2,5.70976431346736 +low-outdegree-n0500-s01729,low-outdegree,500,1729,race/forward-committor,10.655453348795593 +low-outdegree-n0500-s01729,low-outdegree,500,1729,return/mean-recurrence,2.275422166754319 +low-outdegree-n0500-s01729,low-outdegree,500,1729,simulation/10000,16.668681776875914 +low-outdegree-n0500-s01729,low-outdegree,500,1729,simulation/100000,18.588075441706543 +low-outdegree-n0500-s01729,low-outdegree,500,1729,stationary,0.9337896209780348 +low-outdegree-n0500-s01729,low-outdegree,500,1729,structure/classes-cold,12.884100586559756 +low-outdegree-n0500-s01729,low-outdegree,500,1729,structure/classes-lifecycle,7.597671324865271 +low-outdegree-n0500-s01729,low-outdegree,500,1729,structure/classes-warm/access,24.90417591619952 +low-outdegree-n0500-s01729,low-outdegree,500,1729,structure/classes-warm/consumed,11.19192652363077 +low-outdegree-n0500-s01729,low-outdegree,500,1729,structure/irreducible-cold,28.582273937845287 +low-outdegree-n0500-s01729,low-outdegree,500,1729,structure/irreducible-warm,22.764566100692566 +low-outdegree-n0500-s02718,low-outdegree,500,2718,construction/public-consumed,7.700512471659256 +low-outdegree-n0500-s02718,low-outdegree,500,2718,evolution/k-10,3.2987045732977585 +low-outdegree-n0500-s02718,low-outdegree,500,2718,evolution/k-100,1.3842281674877939 +low-outdegree-n0500-s02718,low-outdegree,500,2718,evolution/one-step,21.115204801574507 +low-outdegree-n0500-s02718,low-outdegree,500,2718,hitting-probability/cold-all-states,6.37566273088135 +low-outdegree-n0500-s02718,low-outdegree,500,2718,hitting-time/cold-all-states,12.469339571289002 +low-outdegree-n0500-s02718,low-outdegree,500,2718,power/10,18.146398089063577 +low-outdegree-n0500-s02718,low-outdegree,500,2718,power/100,11.224878340754728 +low-outdegree-n0500-s02718,low-outdegree,500,2718,power/2,5.743052416907981 +low-outdegree-n0500-s02718,low-outdegree,500,2718,race/forward-committor,10.595994906051809 +low-outdegree-n0500-s02718,low-outdegree,500,2718,return/mean-recurrence,2.3723971880776764 +low-outdegree-n0500-s02718,low-outdegree,500,2718,simulation/10000,16.310870121981015 +low-outdegree-n0500-s02718,low-outdegree,500,2718,simulation/100000,18.74525397617628 +low-outdegree-n0500-s02718,low-outdegree,500,2718,stationary,0.9334024712012577 +low-outdegree-n0500-s02718,low-outdegree,500,2718,structure/classes-cold,13.465546573576873 +low-outdegree-n0500-s02718,low-outdegree,500,2718,structure/classes-lifecycle,7.654391892165312 +low-outdegree-n0500-s02718,low-outdegree,500,2718,structure/classes-warm/access,24.772189553933078 +low-outdegree-n0500-s02718,low-outdegree,500,2718,structure/classes-warm/consumed,11.217800972358127 +low-outdegree-n0500-s02718,low-outdegree,500,2718,structure/irreducible-cold,28.522999378539126 +low-outdegree-n0500-s02718,low-outdegree,500,2718,structure/irreducible-warm,23.17534130101916 +low-outdegree-n0500-s31415,low-outdegree,500,31415,construction/public-consumed,7.754539750553886 +low-outdegree-n0500-s31415,low-outdegree,500,31415,evolution/k-10,3.2685018238267682 +low-outdegree-n0500-s31415,low-outdegree,500,31415,evolution/k-100,1.382874584304017 +low-outdegree-n0500-s31415,low-outdegree,500,31415,evolution/one-step,20.752810720430986 +low-outdegree-n0500-s31415,low-outdegree,500,31415,hitting-probability/cold-all-states,6.446331012883586 +low-outdegree-n0500-s31415,low-outdegree,500,31415,hitting-time/cold-all-states,12.474496585851618 +low-outdegree-n0500-s31415,low-outdegree,500,31415,power/10,17.896107913763196 +low-outdegree-n0500-s31415,low-outdegree,500,31415,power/100,11.235588739753116 +low-outdegree-n0500-s31415,low-outdegree,500,31415,power/2,5.727216669966606 +low-outdegree-n0500-s31415,low-outdegree,500,31415,race/forward-committor,10.597492298859187 +low-outdegree-n0500-s31415,low-outdegree,500,31415,return/mean-recurrence,2.371696290380643 +low-outdegree-n0500-s31415,low-outdegree,500,31415,simulation/10000,16.47140171247755 +low-outdegree-n0500-s31415,low-outdegree,500,31415,simulation/100000,18.857122667275934 +low-outdegree-n0500-s31415,low-outdegree,500,31415,stationary,0.9387781481644061 +low-outdegree-n0500-s31415,low-outdegree,500,31415,structure/classes-cold,13.311248500453333 +low-outdegree-n0500-s31415,low-outdegree,500,31415,structure/classes-lifecycle,7.606894507891868 +low-outdegree-n0500-s31415,low-outdegree,500,31415,structure/classes-warm/access,24.605955820842343 +low-outdegree-n0500-s31415,low-outdegree,500,31415,structure/classes-warm/consumed,11.220793710080276 +low-outdegree-n0500-s31415,low-outdegree,500,31415,structure/irreducible-cold,28.69751715951051 +low-outdegree-n0500-s31415,low-outdegree,500,31415,structure/irreducible-warm,23.26017926344601 +low-outdegree-n1000-s01729,low-outdegree,1000,1729,construction/public-consumed,6.866540744518417 +low-outdegree-n1000-s01729,low-outdegree,1000,1729,evolution/k-10,1.7443497672611785 +low-outdegree-n1000-s01729,low-outdegree,1000,1729,evolution/k-100,0.9237807872703077 +low-outdegree-n1000-s01729,low-outdegree,1000,1729,evolution/one-step,8.248994105173212 +low-outdegree-n1000-s01729,low-outdegree,1000,1729,simulation/10000,15.635223691422278 +low-outdegree-n1000-s01729,low-outdegree,1000,1729,simulation/100000,24.205641656308238 +low-outdegree-n1000-s01729,low-outdegree,1000,1729,structure/classes-cold,18.788644181236705 +low-outdegree-n1000-s01729,low-outdegree,1000,1729,structure/classes-lifecycle,6.843083378867198 +low-outdegree-n1000-s01729,low-outdegree,1000,1729,structure/classes-warm/access,23.054999372625456 +low-outdegree-n1000-s01729,low-outdegree,1000,1729,structure/classes-warm/consumed,11.418434676933394 +low-outdegree-n1000-s01729,low-outdegree,1000,1729,structure/irreducible-cold,41.6983302377522 +low-outdegree-n1000-s01729,low-outdegree,1000,1729,structure/irreducible-warm,23.466863250858857 +low-outdegree-n1000-s02718,low-outdegree,1000,2718,construction/public-consumed,6.789792780795602 +low-outdegree-n1000-s02718,low-outdegree,1000,2718,evolution/k-10,1.9110760159979148 +low-outdegree-n1000-s02718,low-outdegree,1000,2718,evolution/k-100,0.968424034337219 +low-outdegree-n1000-s02718,low-outdegree,1000,2718,evolution/one-step,8.207623268552606 +low-outdegree-n1000-s02718,low-outdegree,1000,2718,simulation/10000,15.59400509847432 +low-outdegree-n1000-s02718,low-outdegree,1000,2718,simulation/100000,23.97846187568549 +low-outdegree-n1000-s02718,low-outdegree,1000,2718,structure/classes-cold,18.515050618952472 +low-outdegree-n1000-s02718,low-outdegree,1000,2718,structure/classes-lifecycle,6.826547590268328 +low-outdegree-n1000-s02718,low-outdegree,1000,2718,structure/classes-warm/access,25.531267331250277 +low-outdegree-n1000-s02718,low-outdegree,1000,2718,structure/classes-warm/consumed,11.445373359789404 +low-outdegree-n1000-s02718,low-outdegree,1000,2718,structure/irreducible-cold,41.60126961255533 +low-outdegree-n1000-s02718,low-outdegree,1000,2718,structure/irreducible-warm,23.188976078774246 +low-outdegree-n1000-s31415,low-outdegree,1000,31415,construction/public-consumed,6.777920143930915 +low-outdegree-n1000-s31415,low-outdegree,1000,31415,evolution/k-10,2.2956430685295417 +low-outdegree-n1000-s31415,low-outdegree,1000,31415,evolution/k-100,1.0835059376723162 +low-outdegree-n1000-s31415,low-outdegree,1000,31415,evolution/one-step,11.56622432405442 +low-outdegree-n1000-s31415,low-outdegree,1000,31415,simulation/10000,16.061212669575454 +low-outdegree-n1000-s31415,low-outdegree,1000,31415,simulation/100000,24.22331365043156 +low-outdegree-n1000-s31415,low-outdegree,1000,31415,structure/classes-cold,19.18366125751877 +low-outdegree-n1000-s31415,low-outdegree,1000,31415,structure/classes-lifecycle,6.891736020038611 +low-outdegree-n1000-s31415,low-outdegree,1000,31415,structure/classes-warm/access,25.453504393292324 +low-outdegree-n1000-s31415,low-outdegree,1000,31415,structure/classes-warm/consumed,11.472498654679544 +low-outdegree-n1000-s31415,low-outdegree,1000,31415,structure/irreducible-cold,42.36814616245963 +low-outdegree-n1000-s31415,low-outdegree,1000,31415,structure/irreducible-warm,23.084004890871157 +periodic-n0010-s01729,periodic,10,1729,construction/public-consumed,54.64709101596796 +periodic-n0010-s01729,periodic,10,1729,evolution/k-10,31.100160956660584 +periodic-n0010-s01729,periodic,10,1729,evolution/k-100,85.74976177792777 +periodic-n0010-s01729,periodic,10,1729,evolution/one-step,120.89864044441347 +periodic-n0010-s01729,periodic,10,1729,finite-time/n-step/k-10,15.559410624460156 +periodic-n0010-s01729,periodic,10,1729,finite-time/n-step/k-100,13.146267847194695 +periodic-n0010-s01729,periodic,10,1729,finite-time/observation/k-10,1.7886743407195107 +periodic-n0010-s01729,periodic,10,1729,finite-time/observation/k-100,1.0178481232848555 +periodic-n0010-s01729,periodic,10,1729,finite-time/step,1.220767513819942 +periodic-n0010-s01729,periodic,10,1729,hitting-probability/cold-all-states,2.768235127350918 +periodic-n0010-s01729,periodic,10,1729,hitting-time/cold-all-states,6.406490764300346 +periodic-n0010-s01729,periodic,10,1729,hitting/bounded/at-most/k-10,16.708918441135737 +periodic-n0010-s01729,periodic,10,1729,hitting/bounded/at-most/k-100,128.20330041397358 +periodic-n0010-s01729,periodic,10,1729,hitting/bounded/exact/k-10,17.059341252516568 +periodic-n0010-s01729,periodic,10,1729,hitting/bounded/exact/k-100,138.0786655213835 +periodic-n0010-s01729,periodic,10,1729,hitting/bounded/greater-than/k-10,17.535116882768477 +periodic-n0010-s01729,periodic,10,1729,hitting/bounded/greater-than/k-100,137.4987744971928 +periodic-n0010-s01729,periodic,10,1729,power/10,65.25629933476618 +periodic-n0010-s01729,periodic,10,1729,power/100,51.15341429530325 +periodic-n0010-s01729,periodic,10,1729,power/2,85.63134724291429 +periodic-n0010-s01729,periodic,10,1729,return/bounded/k-10,12.582252541104715 +periodic-n0010-s01729,periodic,10,1729,return/bounded/k-100,96.56394841269397 +periodic-n0010-s01729,periodic,10,1729,stationary,12.475210806703185 +periodic-n0010-s01729,periodic,10,1729,structure/classes-cold,7.525558258379193 +periodic-n0010-s01729,periodic,10,1729,structure/classes-lifecycle,51.29165423318535 +periodic-n0010-s01729,periodic,10,1729,structure/classes-warm/access,24.921270292789192 +periodic-n0010-s01729,periodic,10,1729,structure/classes-warm/consumed,22.92312531383075 +periodic-n0010-s01729,periodic,10,1729,structure/cyclic-classes-cold,63.225737364072934 +periodic-n0010-s01729,periodic,10,1729,structure/cyclic-classes-warm,1.2460322056031743 +periodic-n0010-s01729,periodic,10,1729,structure/irreducible-cold,11.082077953562044 +periodic-n0010-s01729,periodic,10,1729,structure/irreducible-warm,23.194130737717003 +periodic-n0010-s01729,periodic,10,1729,structure/period-cold,43.70957341250406 +periodic-n0010-s01729,periodic,10,1729,structure/period-warm,19.330526944538008 +periodic-n0010-s01729,periodic,10,1729,visits/bounded-expectation/k-10,6.838369970568266 +periodic-n0010-s01729,periodic,10,1729,visits/bounded-expectation/k-100,4.530835540774664 +periodic-n0010-s02718,periodic,10,2718,construction/public-consumed,54.66446149349568 +periodic-n0010-s02718,periodic,10,2718,evolution/k-10,31.624554463886124 +periodic-n0010-s02718,periodic,10,2718,evolution/k-100,84.75826679362014 +periodic-n0010-s02718,periodic,10,2718,evolution/one-step,120.34877973319838 +periodic-n0010-s02718,periodic,10,2718,finite-time/n-step/k-10,15.460857243934512 +periodic-n0010-s02718,periodic,10,2718,finite-time/n-step/k-100,13.154749946117697 +periodic-n0010-s02718,periodic,10,2718,finite-time/observation/k-10,1.788203910172341 +periodic-n0010-s02718,periodic,10,2718,finite-time/observation/k-100,0.98369086540849 +periodic-n0010-s02718,periodic,10,2718,finite-time/step,1.1578735714901742 +periodic-n0010-s02718,periodic,10,2718,hitting-probability/cold-all-states,2.9199502186256954 +periodic-n0010-s02718,periodic,10,2718,hitting-time/cold-all-states,6.44926679774369 +periodic-n0010-s02718,periodic,10,2718,hitting/bounded/at-most/k-10,17.030408897945577 +periodic-n0010-s02718,periodic,10,2718,hitting/bounded/at-most/k-100,132.57188669250465 +periodic-n0010-s02718,periodic,10,2718,hitting/bounded/exact/k-10,17.04459529215396 +periodic-n0010-s02718,periodic,10,2718,hitting/bounded/exact/k-100,136.04230812300673 +periodic-n0010-s02718,periodic,10,2718,hitting/bounded/greater-than/k-10,17.864066620816075 +periodic-n0010-s02718,periodic,10,2718,hitting/bounded/greater-than/k-100,138.3229774063613 +periodic-n0010-s02718,periodic,10,2718,power/10,65.04297907827448 +periodic-n0010-s02718,periodic,10,2718,power/100,51.2788014043883 +periodic-n0010-s02718,periodic,10,2718,power/2,84.97058125914184 +periodic-n0010-s02718,periodic,10,2718,return/bounded/k-10,12.576744923876282 +periodic-n0010-s02718,periodic,10,2718,return/bounded/k-100,97.9558914116979 +periodic-n0010-s02718,periodic,10,2718,stationary,12.391185423021614 +periodic-n0010-s02718,periodic,10,2718,structure/classes-cold,7.212736945832682 +periodic-n0010-s02718,periodic,10,2718,structure/classes-lifecycle,52.139913234854426 +periodic-n0010-s02718,periodic,10,2718,structure/classes-warm/access,25.362276722838832 +periodic-n0010-s02718,periodic,10,2718,structure/classes-warm/consumed,22.815858619284725 +periodic-n0010-s02718,periodic,10,2718,structure/cyclic-classes-cold,61.64053452765248 +periodic-n0010-s02718,periodic,10,2718,structure/cyclic-classes-warm,1.2432737536356775 +periodic-n0010-s02718,periodic,10,2718,structure/irreducible-cold,10.551446271591445 +periodic-n0010-s02718,periodic,10,2718,structure/irreducible-warm,23.338430193232533 +periodic-n0010-s02718,periodic,10,2718,structure/period-cold,43.87501548474328 +periodic-n0010-s02718,periodic,10,2718,structure/period-warm,19.304303091818046 +periodic-n0010-s02718,periodic,10,2718,visits/bounded-expectation/k-10,6.99036221860108 +periodic-n0010-s02718,periodic,10,2718,visits/bounded-expectation/k-100,4.557014579531246 +periodic-n0010-s31415,periodic,10,31415,construction/public-consumed,55.44623309696875 +periodic-n0010-s31415,periodic,10,31415,evolution/k-10,30.948881873336127 +periodic-n0010-s31415,periodic,10,31415,evolution/k-100,85.22708398237395 +periodic-n0010-s31415,periodic,10,31415,evolution/one-step,119.77903859300493 +periodic-n0010-s31415,periodic,10,31415,finite-time/n-step/k-10,15.561739118244127 +periodic-n0010-s31415,periodic,10,31415,finite-time/n-step/k-100,13.26508280161302 +periodic-n0010-s31415,periodic,10,31415,finite-time/observation/k-10,1.8092207264656628 +periodic-n0010-s31415,periodic,10,31415,finite-time/observation/k-100,1.0330499648506535 +periodic-n0010-s31415,periodic,10,31415,finite-time/step,1.0900219727826688 +periodic-n0010-s31415,periodic,10,31415,hitting-probability/cold-all-states,2.7126961181254283 +periodic-n0010-s31415,periodic,10,31415,hitting-time/cold-all-states,5.82738559937836 +periodic-n0010-s31415,periodic,10,31415,hitting/bounded/at-most/k-10,16.83133695941931 +periodic-n0010-s31415,periodic,10,31415,hitting/bounded/at-most/k-100,130.63856472577194 +periodic-n0010-s31415,periodic,10,31415,hitting/bounded/exact/k-10,16.77103724995085 +periodic-n0010-s31415,periodic,10,31415,hitting/bounded/exact/k-100,135.09177750246124 +periodic-n0010-s31415,periodic,10,31415,hitting/bounded/greater-than/k-10,18.099426389496884 +periodic-n0010-s31415,periodic,10,31415,hitting/bounded/greater-than/k-100,134.41140593655956 +periodic-n0010-s31415,periodic,10,31415,power/10,65.70282540281626 +periodic-n0010-s31415,periodic,10,31415,power/100,51.03336070202528 +periodic-n0010-s31415,periodic,10,31415,power/2,85.60431868643532 +periodic-n0010-s31415,periodic,10,31415,return/bounded/k-10,12.611123817072873 +periodic-n0010-s31415,periodic,10,31415,return/bounded/k-100,97.32144484888434 +periodic-n0010-s31415,periodic,10,31415,stationary,12.117854982437718 +periodic-n0010-s31415,periodic,10,31415,structure/classes-cold,7.263156087451714 +periodic-n0010-s31415,periodic,10,31415,structure/classes-lifecycle,51.486129519226964 +periodic-n0010-s31415,periodic,10,31415,structure/classes-warm/access,24.9327643190484 +periodic-n0010-s31415,periodic,10,31415,structure/classes-warm/consumed,22.89915892428147 +periodic-n0010-s31415,periodic,10,31415,structure/cyclic-classes-cold,60.5766432699415 +periodic-n0010-s31415,periodic,10,31415,structure/cyclic-classes-warm,1.2421582528003883 +periodic-n0010-s31415,periodic,10,31415,structure/irreducible-cold,10.770165606403799 +periodic-n0010-s31415,periodic,10,31415,structure/irreducible-warm,23.13570022107864 +periodic-n0010-s31415,periodic,10,31415,structure/period-cold,43.42360187097345 +periodic-n0010-s31415,periodic,10,31415,structure/period-warm,19.149600517743156 +periodic-n0010-s31415,periodic,10,31415,visits/bounded-expectation/k-10,6.975896490522846 +periodic-n0010-s31415,periodic,10,31415,visits/bounded-expectation/k-100,4.470938771015665 +periodic-n0025-s01729,periodic,25,1729,construction/public-consumed,22.275046252104563 +periodic-n0025-s01729,periodic,25,1729,evolution/k-10,27.86408105670362 +periodic-n0025-s01729,periodic,25,1729,evolution/k-100,32.65127534280811 +periodic-n0025-s01729,periodic,25,1729,evolution/one-step,109.70855134672469 +periodic-n0025-s01729,periodic,25,1729,finite-time/n-step/k-10,14.565826339368364 +periodic-n0025-s01729,periodic,25,1729,finite-time/n-step/k-100,9.52770308208095 +periodic-n0025-s01729,periodic,25,1729,finite-time/observation/k-10,0.5925635441408487 +periodic-n0025-s01729,periodic,25,1729,finite-time/observation/k-100,0.27653151916308355 +periodic-n0025-s01729,periodic,25,1729,finite-time/step,1.4629678426655255 +periodic-n0025-s01729,periodic,25,1729,hitting-probability/cold-all-states,1.847648897034529 +periodic-n0025-s01729,periodic,25,1729,hitting-time/cold-all-states,4.068171052168515 +periodic-n0025-s01729,periodic,25,1729,hitting/bounded/at-most/k-10,11.858690294797738 +periodic-n0025-s01729,periodic,25,1729,hitting/bounded/at-most/k-100,91.18980272861036 +periodic-n0025-s01729,periodic,25,1729,hitting/bounded/exact/k-10,12.166084722794622 +periodic-n0025-s01729,periodic,25,1729,hitting/bounded/exact/k-100,91.74131582205513 +periodic-n0025-s01729,periodic,25,1729,hitting/bounded/greater-than/k-10,13.031182239446034 +periodic-n0025-s01729,periodic,25,1729,hitting/bounded/greater-than/k-100,93.86694169509212 +periodic-n0025-s01729,periodic,25,1729,power/10,23.661871397121566 +periodic-n0025-s01729,periodic,25,1729,power/100,17.728720309926562 +periodic-n0025-s01729,periodic,25,1729,power/2,25.427802031010994 +periodic-n0025-s01729,periodic,25,1729,return/bounded/k-10,13.556370170961527 +periodic-n0025-s01729,periodic,25,1729,return/bounded/k-100,56.814276655810964 +periodic-n0025-s01729,periodic,25,1729,stationary,10.77696810161444 +periodic-n0025-s01729,periodic,25,1729,structure/classes-cold,8.240430076155828 +periodic-n0025-s01729,periodic,25,1729,structure/classes-lifecycle,22.174671049935704 +periodic-n0025-s01729,periodic,25,1729,structure/classes-warm/access,25.434854171625165 +periodic-n0025-s01729,periodic,25,1729,structure/classes-warm/consumed,16.256845059595296 +periodic-n0025-s01729,periodic,25,1729,structure/cyclic-classes-cold,111.76676136071544 +periodic-n0025-s01729,periodic,25,1729,structure/cyclic-classes-warm,1.0889956723793186 +periodic-n0025-s01729,periodic,25,1729,structure/irreducible-cold,13.973089940282593 +periodic-n0025-s01729,periodic,25,1729,structure/irreducible-warm,24.027569909116238 +periodic-n0025-s01729,periodic,25,1729,structure/period-cold,71.73107047081099 +periodic-n0025-s01729,periodic,25,1729,structure/period-warm,19.30085147870817 +periodic-n0025-s01729,periodic,25,1729,visits/bounded-expectation/k-10,7.916593185399224 +periodic-n0025-s01729,periodic,25,1729,visits/bounded-expectation/k-100,3.4197052601587257 +periodic-n0025-s02718,periodic,25,2718,construction/public-consumed,22.168529598909554 +periodic-n0025-s02718,periodic,25,2718,evolution/k-10,27.833837807201792 +periodic-n0025-s02718,periodic,25,2718,evolution/k-100,31.977342081603165 +periodic-n0025-s02718,periodic,25,2718,evolution/one-step,107.48327830856937 +periodic-n0025-s02718,periodic,25,2718,finite-time/n-step/k-10,14.74704135536207 +periodic-n0025-s02718,periodic,25,2718,finite-time/n-step/k-100,9.457298840595993 +periodic-n0025-s02718,periodic,25,2718,finite-time/observation/k-10,0.6012202434615307 +periodic-n0025-s02718,periodic,25,2718,finite-time/observation/k-100,0.2750801651766794 +periodic-n0025-s02718,periodic,25,2718,finite-time/step,1.5878942210660083 +periodic-n0025-s02718,periodic,25,2718,hitting-probability/cold-all-states,1.8875310141091346 +periodic-n0025-s02718,periodic,25,2718,hitting-time/cold-all-states,4.2500492734600455 +periodic-n0025-s02718,periodic,25,2718,hitting/bounded/at-most/k-10,12.205951171554712 +periodic-n0025-s02718,periodic,25,2718,hitting/bounded/at-most/k-100,90.82062079085762 +periodic-n0025-s02718,periodic,25,2718,hitting/bounded/exact/k-10,12.61140319915477 +periodic-n0025-s02718,periodic,25,2718,hitting/bounded/exact/k-100,96.2916991065443 +periodic-n0025-s02718,periodic,25,2718,hitting/bounded/greater-than/k-10,11.859479927853045 +periodic-n0025-s02718,periodic,25,2718,hitting/bounded/greater-than/k-100,98.9415492094777 +periodic-n0025-s02718,periodic,25,2718,power/10,20.918717375317375 +periodic-n0025-s02718,periodic,25,2718,power/100,17.33541279287878 +periodic-n0025-s02718,periodic,25,2718,power/2,25.90581947258338 +periodic-n0025-s02718,periodic,25,2718,return/bounded/k-10,12.967048956375372 +periodic-n0025-s02718,periodic,25,2718,return/bounded/k-100,55.32373957304512 +periodic-n0025-s02718,periodic,25,2718,stationary,10.957357199033439 +periodic-n0025-s02718,periodic,25,2718,structure/classes-cold,8.111237137586173 +periodic-n0025-s02718,periodic,25,2718,structure/classes-lifecycle,22.108140279673776 +periodic-n0025-s02718,periodic,25,2718,structure/classes-warm/access,27.67006970681481 +periodic-n0025-s02718,periodic,25,2718,structure/classes-warm/consumed,16.160174057472435 +periodic-n0025-s02718,periodic,25,2718,structure/cyclic-classes-cold,88.14040779654893 +periodic-n0025-s02718,periodic,25,2718,structure/cyclic-classes-warm,1.0233788381021942 +periodic-n0025-s02718,periodic,25,2718,structure/irreducible-cold,13.836129935479832 +periodic-n0025-s02718,periodic,25,2718,structure/irreducible-warm,23.113931516201074 +periodic-n0025-s02718,periodic,25,2718,structure/period-cold,71.07176463888987 +periodic-n0025-s02718,periodic,25,2718,structure/period-warm,19.28399539082752 +periodic-n0025-s02718,periodic,25,2718,visits/bounded-expectation/k-10,7.821970077935814 +periodic-n0025-s02718,periodic,25,2718,visits/bounded-expectation/k-100,3.2735011914321563 +periodic-n0025-s31415,periodic,25,31415,construction/public-consumed,25.658727294305386 +periodic-n0025-s31415,periodic,25,31415,evolution/k-10,29.871832500936286 +periodic-n0025-s31415,periodic,25,31415,evolution/k-100,33.33973152079969 +periodic-n0025-s31415,periodic,25,31415,evolution/one-step,111.30307451570198 +periodic-n0025-s31415,periodic,25,31415,finite-time/n-step/k-10,14.713464406498472 +periodic-n0025-s31415,periodic,25,31415,finite-time/n-step/k-100,9.319892404378997 +periodic-n0025-s31415,periodic,25,31415,finite-time/observation/k-10,0.6267241155715333 +periodic-n0025-s31415,periodic,25,31415,finite-time/observation/k-100,0.26726269218599213 +periodic-n0025-s31415,periodic,25,31415,finite-time/step,1.601815706410365 +periodic-n0025-s31415,periodic,25,31415,hitting-probability/cold-all-states,1.7858212384996854 +periodic-n0025-s31415,periodic,25,31415,hitting-time/cold-all-states,4.067418115184078 +periodic-n0025-s31415,periodic,25,31415,hitting/bounded/at-most/k-10,12.497840560216423 +periodic-n0025-s31415,periodic,25,31415,hitting/bounded/at-most/k-100,93.80409148197232 +periodic-n0025-s31415,periodic,25,31415,hitting/bounded/exact/k-10,12.56816595155099 +periodic-n0025-s31415,periodic,25,31415,hitting/bounded/exact/k-100,100.15024850399142 +periodic-n0025-s31415,periodic,25,31415,hitting/bounded/greater-than/k-10,13.556865592056967 +periodic-n0025-s31415,periodic,25,31415,hitting/bounded/greater-than/k-100,97.48538697777634 +periodic-n0025-s31415,periodic,25,31415,power/10,22.269157075103898 +periodic-n0025-s31415,periodic,25,31415,power/100,17.572186100239087 +periodic-n0025-s31415,periodic,25,31415,power/2,26.59530727372952 +periodic-n0025-s31415,periodic,25,31415,return/bounded/k-10,13.995303087198264 +periodic-n0025-s31415,periodic,25,31415,return/bounded/k-100,55.150228285754935 +periodic-n0025-s31415,periodic,25,31415,stationary,10.124466535786468 +periodic-n0025-s31415,periodic,25,31415,structure/classes-cold,8.842104461749084 +periodic-n0025-s31415,periodic,25,31415,structure/classes-lifecycle,23.050880927527565 +periodic-n0025-s31415,periodic,25,31415,structure/classes-warm/access,25.992483833211224 +periodic-n0025-s31415,periodic,25,31415,structure/classes-warm/consumed,16.536128238955804 +periodic-n0025-s31415,periodic,25,31415,structure/cyclic-classes-cold,88.12468288451196 +periodic-n0025-s31415,periodic,25,31415,structure/cyclic-classes-warm,1.017711063811528 +periodic-n0025-s31415,periodic,25,31415,structure/irreducible-cold,14.466787527714144 +periodic-n0025-s31415,periodic,25,31415,structure/irreducible-warm,23.245417781690197 +periodic-n0025-s31415,periodic,25,31415,structure/period-cold,73.00004820547689 +periodic-n0025-s31415,periodic,25,31415,structure/period-warm,18.992265390529813 +periodic-n0025-s31415,periodic,25,31415,visits/bounded-expectation/k-10,7.921514988158539 +periodic-n0025-s31415,periodic,25,31415,visits/bounded-expectation/k-100,3.282436346902015 +periodic-n0050-s01729,periodic,50,1729,construction/public-consumed,16.937950314784345 +periodic-n0050-s01729,periodic,50,1729,evolution/k-10,19.900814450422565 +periodic-n0050-s01729,periodic,50,1729,evolution/k-100,15.319774973275862 +periodic-n0050-s01729,periodic,50,1729,evolution/one-step,84.82845451709532 +periodic-n0050-s01729,periodic,50,1729,finite-time/n-step/k-10,14.57825100397168 +periodic-n0050-s01729,periodic,50,1729,finite-time/n-step/k-100,7.393916808288508 +periodic-n0050-s01729,periodic,50,1729,finite-time/observation/k-10,0.2859226110583617 +periodic-n0050-s01729,periodic,50,1729,finite-time/observation/k-100,0.11047807730119956 +periodic-n0050-s01729,periodic,50,1729,finite-time/step,1.7638992842947543 +periodic-n0050-s01729,periodic,50,1729,hitting-probability/cold-all-states,1.6500452980683877 +periodic-n0050-s01729,periodic,50,1729,hitting-time/cold-all-states,3.621015033494674 +periodic-n0050-s01729,periodic,50,1729,hitting/bounded/at-most/k-10,12.834289927457265 +periodic-n0050-s01729,periodic,50,1729,hitting/bounded/at-most/k-100,58.61303176476206 +periodic-n0050-s01729,periodic,50,1729,hitting/bounded/exact/k-10,13.602468437468557 +periodic-n0050-s01729,periodic,50,1729,hitting/bounded/exact/k-100,59.23636425800852 +periodic-n0050-s01729,periodic,50,1729,hitting/bounded/greater-than/k-10,13.576091052098779 +periodic-n0050-s01729,periodic,50,1729,hitting/bounded/greater-than/k-100,59.409452646608024 +periodic-n0050-s01729,periodic,50,1729,power/10,11.29555501171033 +periodic-n0050-s01729,periodic,50,1729,power/100,8.947253585531257 +periodic-n0050-s01729,periodic,50,1729,power/2,12.820075189369271 +periodic-n0050-s01729,periodic,50,1729,return/bounded/k-10,13.918780161889716 +periodic-n0050-s01729,periodic,50,1729,return/bounded/k-100,32.537943333572464 +periodic-n0050-s01729,periodic,50,1729,stationary,6.228483366061593 +periodic-n0050-s01729,periodic,50,1729,structure/classes-cold,9.531766270101757 +periodic-n0050-s01729,periodic,50,1729,structure/classes-lifecycle,17.058614295855012 +periodic-n0050-s01729,periodic,50,1729,structure/classes-warm/access,25.158141090156516 +periodic-n0050-s01729,periodic,50,1729,structure/classes-warm/consumed,12.824418963831285 +periodic-n0050-s01729,periodic,50,1729,structure/cyclic-classes-cold,124.24358644189608 +periodic-n0050-s01729,periodic,50,1729,structure/cyclic-classes-warm,0.9485422966401185 +periodic-n0050-s01729,periodic,50,1729,structure/irreducible-cold,17.58123237980971 +periodic-n0050-s01729,periodic,50,1729,structure/irreducible-warm,23.271129056366853 +periodic-n0050-s01729,periodic,50,1729,structure/period-cold,111.4175052970104 +periodic-n0050-s01729,periodic,50,1729,structure/period-warm,19.373392827280515 +periodic-n0050-s01729,periodic,50,1729,visits/bounded-expectation/k-10,9.858165415775366 +periodic-n0050-s01729,periodic,50,1729,visits/bounded-expectation/k-100,3.162956877860361 +periodic-n0050-s02718,periodic,50,2718,construction/public-consumed,16.878903282960994 +periodic-n0050-s02718,periodic,50,2718,evolution/k-10,18.342889621445803 +periodic-n0050-s02718,periodic,50,2718,evolution/k-100,15.615972431202175 +periodic-n0050-s02718,periodic,50,2718,evolution/one-step,84.46529204713215 +periodic-n0050-s02718,periodic,50,2718,finite-time/n-step/k-10,14.675580779348357 +periodic-n0050-s02718,periodic,50,2718,finite-time/n-step/k-100,7.389970332445747 +periodic-n0050-s02718,periodic,50,2718,finite-time/observation/k-10,0.28218916208703326 +periodic-n0050-s02718,periodic,50,2718,finite-time/observation/k-100,0.10960787058561049 +periodic-n0050-s02718,periodic,50,2718,finite-time/step,1.7217236752687797 +periodic-n0050-s02718,periodic,50,2718,hitting-probability/cold-all-states,1.6390481517244162 +periodic-n0050-s02718,periodic,50,2718,hitting-time/cold-all-states,3.66019068342748 +periodic-n0050-s02718,periodic,50,2718,hitting/bounded/at-most/k-10,13.590022650997224 +periodic-n0050-s02718,periodic,50,2718,hitting/bounded/at-most/k-100,58.73739092064314 +periodic-n0050-s02718,periodic,50,2718,hitting/bounded/exact/k-10,13.506617545584577 +periodic-n0050-s02718,periodic,50,2718,hitting/bounded/exact/k-100,59.693807861615355 +periodic-n0050-s02718,periodic,50,2718,hitting/bounded/greater-than/k-10,13.74673978378201 +periodic-n0050-s02718,periodic,50,2718,hitting/bounded/greater-than/k-100,58.94501211780501 +periodic-n0050-s02718,periodic,50,2718,power/10,10.733674082778476 +periodic-n0050-s02718,periodic,50,2718,power/100,9.027907037901347 +periodic-n0050-s02718,periodic,50,2718,power/2,12.297125815171002 +periodic-n0050-s02718,periodic,50,2718,return/bounded/k-10,14.048635889245764 +periodic-n0050-s02718,periodic,50,2718,return/bounded/k-100,32.30173995764742 +periodic-n0050-s02718,periodic,50,2718,stationary,6.307121599905646 +periodic-n0050-s02718,periodic,50,2718,structure/classes-cold,9.704507240083494 +periodic-n0050-s02718,periodic,50,2718,structure/classes-lifecycle,17.838079390654702 +periodic-n0050-s02718,periodic,50,2718,structure/classes-warm/access,25.311992584378874 +periodic-n0050-s02718,periodic,50,2718,structure/classes-warm/consumed,12.816631933668122 +periodic-n0050-s02718,periodic,50,2718,structure/cyclic-classes-cold,122.81323974493625 +periodic-n0050-s02718,periodic,50,2718,structure/cyclic-classes-warm,0.9515684042023042 +periodic-n0050-s02718,periodic,50,2718,structure/irreducible-cold,17.60934093747317 +periodic-n0050-s02718,periodic,50,2718,structure/irreducible-warm,22.781877946807352 +periodic-n0050-s02718,periodic,50,2718,structure/period-cold,112.0028508806349 +periodic-n0050-s02718,periodic,50,2718,structure/period-warm,19.216553599380052 +periodic-n0050-s02718,periodic,50,2718,visits/bounded-expectation/k-10,9.94003499832713 +periodic-n0050-s02718,periodic,50,2718,visits/bounded-expectation/k-100,3.1954008799493394 +periodic-n0050-s31415,periodic,50,31415,construction/public-consumed,17.051856469223925 +periodic-n0050-s31415,periodic,50,31415,evolution/k-10,19.771532820398836 +periodic-n0050-s31415,periodic,50,31415,evolution/k-100,15.494502642899544 +periodic-n0050-s31415,periodic,50,31415,evolution/one-step,84.00759203559359 +periodic-n0050-s31415,periodic,50,31415,finite-time/n-step/k-10,14.597752161342372 +periodic-n0050-s31415,periodic,50,31415,finite-time/n-step/k-100,7.365913481839748 +periodic-n0050-s31415,periodic,50,31415,finite-time/observation/k-10,0.2866808574342022 +periodic-n0050-s31415,periodic,50,31415,finite-time/observation/k-100,0.10850603981843077 +periodic-n0050-s31415,periodic,50,31415,finite-time/step,1.7562369151313524 +periodic-n0050-s31415,periodic,50,31415,hitting-probability/cold-all-states,1.642583715261392 +periodic-n0050-s31415,periodic,50,31415,hitting-time/cold-all-states,3.6250343671484235 +periodic-n0050-s31415,periodic,50,31415,hitting/bounded/at-most/k-10,13.564456401847632 +periodic-n0050-s31415,periodic,50,31415,hitting/bounded/at-most/k-100,58.01270921461896 +periodic-n0050-s31415,periodic,50,31415,hitting/bounded/exact/k-10,13.371298108077944 +periodic-n0050-s31415,periodic,50,31415,hitting/bounded/exact/k-100,58.50668779134834 +periodic-n0050-s31415,periodic,50,31415,hitting/bounded/greater-than/k-10,13.8243842561793 +periodic-n0050-s31415,periodic,50,31415,hitting/bounded/greater-than/k-100,59.42900763442895 +periodic-n0050-s31415,periodic,50,31415,power/10,10.680475461594366 +periodic-n0050-s31415,periodic,50,31415,power/100,9.00954019483761 +periodic-n0050-s31415,periodic,50,31415,power/2,12.214582842430655 +periodic-n0050-s31415,periodic,50,31415,return/bounded/k-10,14.223949467606381 +periodic-n0050-s31415,periodic,50,31415,return/bounded/k-100,32.413426314498786 +periodic-n0050-s31415,periodic,50,31415,stationary,6.292193326622928 +periodic-n0050-s31415,periodic,50,31415,structure/classes-cold,9.34592299542508 +periodic-n0050-s31415,periodic,50,31415,structure/classes-lifecycle,16.864797776856847 +periodic-n0050-s31415,periodic,50,31415,structure/classes-warm/access,25.014717897596288 +periodic-n0050-s31415,periodic,50,31415,structure/classes-warm/consumed,12.851602970280796 +periodic-n0050-s31415,periodic,50,31415,structure/cyclic-classes-cold,124.42710295101242 +periodic-n0050-s31415,periodic,50,31415,structure/cyclic-classes-warm,0.9440676779608378 +periodic-n0050-s31415,periodic,50,31415,structure/irreducible-cold,17.45915425867367 +periodic-n0050-s31415,periodic,50,31415,structure/irreducible-warm,23.065106878044805 +periodic-n0050-s31415,periodic,50,31415,structure/period-cold,109.52350264747213 +periodic-n0050-s31415,periodic,50,31415,structure/period-warm,19.732393891427723 +periodic-n0050-s31415,periodic,50,31415,visits/bounded-expectation/k-10,9.954629436405797 +periodic-n0050-s31415,periodic,50,31415,visits/bounded-expectation/k-100,3.158940330533494 +periodic-n0100-s01729,periodic,100,1729,construction/public-consumed,15.412931272271987 +periodic-n0100-s01729,periodic,100,1729,evolution/k-10,13.410749437591305 +periodic-n0100-s01729,periodic,100,1729,evolution/k-100,4.6055643674940105 +periodic-n0100-s01729,periodic,100,1729,evolution/one-step,65.75943729366765 +periodic-n0100-s01729,periodic,100,1729,finite-time/n-step/k-10,15.127752164949593 +periodic-n0100-s01729,periodic,100,1729,finite-time/n-step/k-100,6.18320289029251 +periodic-n0100-s01729,periodic,100,1729,finite-time/observation/k-10,0.13773469397068216 +periodic-n0100-s01729,periodic,100,1729,finite-time/observation/k-100,0.04876509933722393 +periodic-n0100-s01729,periodic,100,1729,finite-time/step,3.0359774978653506 +periodic-n0100-s01729,periodic,100,1729,hitting-probability/cold-all-states,2.12667672876421 +periodic-n0100-s01729,periodic,100,1729,hitting-time/cold-all-states,4.604903758856842 +periodic-n0100-s01729,periodic,100,1729,hitting/bounded/at-most/k-10,18.440762260580552 +periodic-n0100-s01729,periodic,100,1729,hitting/bounded/at-most/k-100,43.14233664504645 +periodic-n0100-s01729,periodic,100,1729,hitting/bounded/exact/k-10,18.319395334813475 +periodic-n0100-s01729,periodic,100,1729,hitting/bounded/exact/k-100,43.36917939582149 +periodic-n0100-s01729,periodic,100,1729,hitting/bounded/greater-than/k-10,18.589655537334263 +periodic-n0100-s01729,periodic,100,1729,hitting/bounded/greater-than/k-100,43.454769778754574 +periodic-n0100-s01729,periodic,100,1729,power/10,6.735414501906548 +periodic-n0100-s01729,periodic,100,1729,power/100,5.164465245736242 +periodic-n0100-s01729,periodic,100,1729,power/2,8.208333631215506 +periodic-n0100-s01729,periodic,100,1729,return/bounded/k-10,19.123942680257702 +periodic-n0100-s01729,periodic,100,1729,return/bounded/k-100,23.16456481928584 +periodic-n0100-s01729,periodic,100,1729,stationary,2.6800510292256488 +periodic-n0100-s01729,periodic,100,1729,structure/classes-cold,11.703044313667322 +periodic-n0100-s01729,periodic,100,1729,structure/classes-lifecycle,15.321731812427512 +periodic-n0100-s01729,periodic,100,1729,structure/classes-warm/access,25.440638197564297 +periodic-n0100-s01729,periodic,100,1729,structure/classes-warm/consumed,12.138165605926654 +periodic-n0100-s01729,periodic,100,1729,structure/cyclic-classes-cold,183.54529826012092 +periodic-n0100-s01729,periodic,100,1729,structure/cyclic-classes-warm,0.9138554526118922 +periodic-n0100-s01729,periodic,100,1729,structure/irreducible-cold,23.579108838792735 +periodic-n0100-s01729,periodic,100,1729,structure/irreducible-warm,23.436638261418278 +periodic-n0100-s01729,periodic,100,1729,structure/period-cold,191.88885832927417 +periodic-n0100-s01729,periodic,100,1729,structure/period-warm,19.640984301500485 +periodic-n0100-s01729,periodic,100,1729,visits/bounded-expectation/k-10,11.747825970739704 +periodic-n0100-s01729,periodic,100,1729,visits/bounded-expectation/k-100,3.2913340269560796 +periodic-n0100-s02718,periodic,100,2718,construction/public-consumed,15.276784170498814 +periodic-n0100-s02718,periodic,100,2718,evolution/k-10,13.442922554671215 +periodic-n0100-s02718,periodic,100,2718,evolution/k-100,4.568872100874481 +periodic-n0100-s02718,periodic,100,2718,evolution/one-step,67.692149139173 +periodic-n0100-s02718,periodic,100,2718,finite-time/n-step/k-10,15.120602393504614 +periodic-n0100-s02718,periodic,100,2718,finite-time/n-step/k-100,6.2564851248664475 +periodic-n0100-s02718,periodic,100,2718,finite-time/observation/k-10,0.13712332938722996 +periodic-n0100-s02718,periodic,100,2718,finite-time/observation/k-100,0.049044848622771905 +periodic-n0100-s02718,periodic,100,2718,finite-time/step,3.15113125411072 +periodic-n0100-s02718,periodic,100,2718,hitting-probability/cold-all-states,2.1355893102510315 +periodic-n0100-s02718,periodic,100,2718,hitting-time/cold-all-states,4.611558796459323 +periodic-n0100-s02718,periodic,100,2718,hitting/bounded/at-most/k-10,18.357137546752956 +periodic-n0100-s02718,periodic,100,2718,hitting/bounded/at-most/k-100,43.440608081717045 +periodic-n0100-s02718,periodic,100,2718,hitting/bounded/exact/k-10,18.389065741462666 +periodic-n0100-s02718,periodic,100,2718,hitting/bounded/exact/k-100,43.50225787583511 +periodic-n0100-s02718,periodic,100,2718,hitting/bounded/greater-than/k-10,18.591016305707097 +periodic-n0100-s02718,periodic,100,2718,hitting/bounded/greater-than/k-100,43.5904560024394 +periodic-n0100-s02718,periodic,100,2718,power/10,7.172873563339899 +periodic-n0100-s02718,periodic,100,2718,power/100,5.695483384873724 +periodic-n0100-s02718,periodic,100,2718,power/2,8.149432622167218 +periodic-n0100-s02718,periodic,100,2718,return/bounded/k-10,19.10827936637539 +periodic-n0100-s02718,periodic,100,2718,return/bounded/k-100,23.408419233919986 +periodic-n0100-s02718,periodic,100,2718,stationary,2.7150018654702164 +periodic-n0100-s02718,periodic,100,2718,structure/classes-cold,11.8304376231344 +periodic-n0100-s02718,periodic,100,2718,structure/classes-lifecycle,15.84875136851247 +periodic-n0100-s02718,periodic,100,2718,structure/classes-warm/access,25.191131900435217 +periodic-n0100-s02718,periodic,100,2718,structure/classes-warm/consumed,11.561873123791491 +periodic-n0100-s02718,periodic,100,2718,structure/cyclic-classes-cold,188.9674957027335 +periodic-n0100-s02718,periodic,100,2718,structure/cyclic-classes-warm,0.9152900947279881 +periodic-n0100-s02718,periodic,100,2718,structure/irreducible-cold,23.850509577154057 +periodic-n0100-s02718,periodic,100,2718,structure/irreducible-warm,24.693413220017387 +periodic-n0100-s02718,periodic,100,2718,structure/period-cold,189.41395933143806 +periodic-n0100-s02718,periodic,100,2718,structure/period-warm,19.138337257580176 +periodic-n0100-s02718,periodic,100,2718,visits/bounded-expectation/k-10,12.572742042120453 +periodic-n0100-s02718,periodic,100,2718,visits/bounded-expectation/k-100,3.2896408451303945 +periodic-n0100-s31415,periodic,100,31415,construction/public-consumed,15.245425120903679 +periodic-n0100-s31415,periodic,100,31415,evolution/k-10,13.472820057739938 +periodic-n0100-s31415,periodic,100,31415,evolution/k-100,4.57359816394583 +periodic-n0100-s31415,periodic,100,31415,evolution/one-step,74.8275212805734 +periodic-n0100-s31415,periodic,100,31415,finite-time/n-step/k-10,14.966169696891637 +periodic-n0100-s31415,periodic,100,31415,finite-time/n-step/k-100,6.170019458523326 +periodic-n0100-s31415,periodic,100,31415,finite-time/observation/k-10,0.17473555840866933 +periodic-n0100-s31415,periodic,100,31415,finite-time/observation/k-100,0.04891968123591131 +periodic-n0100-s31415,periodic,100,31415,finite-time/step,2.943423021679245 +periodic-n0100-s31415,periodic,100,31415,hitting-probability/cold-all-states,2.2164322095711464 +periodic-n0100-s31415,periodic,100,31415,hitting-time/cold-all-states,4.60455575683669 +periodic-n0100-s31415,periodic,100,31415,hitting/bounded/at-most/k-10,18.18212231020573 +periodic-n0100-s31415,periodic,100,31415,hitting/bounded/at-most/k-100,47.76449329463414 +periodic-n0100-s31415,periodic,100,31415,hitting/bounded/exact/k-10,18.13757759209501 +periodic-n0100-s31415,periodic,100,31415,hitting/bounded/exact/k-100,42.67150016593965 +periodic-n0100-s31415,periodic,100,31415,hitting/bounded/greater-than/k-10,16.775170394414477 +periodic-n0100-s31415,periodic,100,31415,hitting/bounded/greater-than/k-100,44.2817379240686 +periodic-n0100-s31415,periodic,100,31415,power/10,6.436965624487024 +periodic-n0100-s31415,periodic,100,31415,power/100,5.518021954412691 +periodic-n0100-s31415,periodic,100,31415,power/2,7.939159360946716 +periodic-n0100-s31415,periodic,100,31415,return/bounded/k-10,19.207661218272175 +periodic-n0100-s31415,periodic,100,31415,return/bounded/k-100,23.687598209347914 +periodic-n0100-s31415,periodic,100,31415,stationary,2.685293633090947 +periodic-n0100-s31415,periodic,100,31415,structure/classes-cold,11.839557605967336 +periodic-n0100-s31415,periodic,100,31415,structure/classes-lifecycle,15.297884909231346 +periodic-n0100-s31415,periodic,100,31415,structure/classes-warm/access,24.939276261934232 +periodic-n0100-s31415,periodic,100,31415,structure/classes-warm/consumed,11.39375996942997 +periodic-n0100-s31415,periodic,100,31415,structure/cyclic-classes-cold,183.7108636587149 +periodic-n0100-s31415,periodic,100,31415,structure/cyclic-classes-warm,0.9096206898933655 +periodic-n0100-s31415,periodic,100,31415,structure/irreducible-cold,23.13260278873405 +periodic-n0100-s31415,periodic,100,31415,structure/irreducible-warm,22.95650961123424 +periodic-n0100-s31415,periodic,100,31415,structure/period-cold,187.7825219004296 +periodic-n0100-s31415,periodic,100,31415,structure/period-warm,18.921654349501974 +periodic-n0100-s31415,periodic,100,31415,visits/bounded-expectation/k-10,14.859110818075454 +periodic-n0100-s31415,periodic,100,31415,visits/bounded-expectation/k-100,3.7133281611626128 +periodic-n0250-s01729,periodic,250,1729,construction/public-consumed,10.021930081134387 +periodic-n0250-s01729,periodic,250,1729,evolution/k-10,4.40670438052328 +periodic-n0250-s01729,periodic,250,1729,evolution/k-100,1.6759066707735661 +periodic-n0250-s01729,periodic,250,1729,evolution/one-step,26.915301595932014 +periodic-n0250-s01729,periodic,250,1729,hitting-probability/cold-all-states,4.432450285502626 +periodic-n0250-s01729,periodic,250,1729,hitting-time/cold-all-states,9.296228502962197 +periodic-n0250-s01729,periodic,250,1729,power/10,4.880726816586078 +periodic-n0250-s01729,periodic,250,1729,power/100,3.7392725925346553 +periodic-n0250-s01729,periodic,250,1729,power/2,6.356526537885549 +periodic-n0250-s01729,periodic,250,1729,stationary,1.184485952520946 +periodic-n0250-s01729,periodic,250,1729,structure/classes-cold,15.59944608773749 +periodic-n0250-s01729,periodic,250,1729,structure/classes-lifecycle,10.372468598826382 +periodic-n0250-s01729,periodic,250,1729,structure/classes-warm/access,24.669970319011533 +periodic-n0250-s01729,periodic,250,1729,structure/classes-warm/consumed,10.80434160706453 +periodic-n0250-s01729,periodic,250,1729,structure/cyclic-classes-cold,285.7747511629345 +periodic-n0250-s01729,periodic,250,1729,structure/cyclic-classes-warm,0.8945670637126352 +periodic-n0250-s01729,periodic,250,1729,structure/irreducible-cold,36.226519276175566 +periodic-n0250-s01729,periodic,250,1729,structure/irreducible-warm,23.148375043396296 +periodic-n0250-s01729,periodic,250,1729,structure/period-cold,310.74152172305696 +periodic-n0250-s01729,periodic,250,1729,structure/period-warm,19.607783837995076 +periodic-n0250-s02718,periodic,250,2718,construction/public-consumed,10.437585894155685 +periodic-n0250-s02718,periodic,250,2718,evolution/k-10,4.388436060616922 +periodic-n0250-s02718,periodic,250,2718,evolution/k-100,1.6756733188571251 +periodic-n0250-s02718,periodic,250,2718,evolution/one-step,26.704087683608012 +periodic-n0250-s02718,periodic,250,2718,hitting-probability/cold-all-states,4.435554074484146 +periodic-n0250-s02718,periodic,250,2718,hitting-time/cold-all-states,9.441936180482807 +periodic-n0250-s02718,periodic,250,2718,power/10,4.788426642505176 +periodic-n0250-s02718,periodic,250,2718,power/100,3.724212633672454 +periodic-n0250-s02718,periodic,250,2718,power/2,6.435908909769284 +periodic-n0250-s02718,periodic,250,2718,stationary,1.169486799194331 +periodic-n0250-s02718,periodic,250,2718,structure/classes-cold,15.32147528905083 +periodic-n0250-s02718,periodic,250,2718,structure/classes-lifecycle,10.452310894493312 +periodic-n0250-s02718,periodic,250,2718,structure/classes-warm/access,24.572007279734553 +periodic-n0250-s02718,periodic,250,2718,structure/classes-warm/consumed,10.763386269619597 +periodic-n0250-s02718,periodic,250,2718,structure/cyclic-classes-cold,277.58149866115366 +periodic-n0250-s02718,periodic,250,2718,structure/cyclic-classes-warm,0.8901041486409926 +periodic-n0250-s02718,periodic,250,2718,structure/irreducible-cold,30.212585997975815 +periodic-n0250-s02718,periodic,250,2718,structure/irreducible-warm,23.104527576074727 +periodic-n0250-s02718,periodic,250,2718,structure/period-cold,302.656076886994 +periodic-n0250-s02718,periodic,250,2718,structure/period-warm,19.04993407996588 +periodic-n0250-s31415,periodic,250,31415,construction/public-consumed,10.467053133048925 +periodic-n0250-s31415,periodic,250,31415,evolution/k-10,4.724453088984914 +periodic-n0250-s31415,periodic,250,31415,evolution/k-100,1.7108288230658732 +periodic-n0250-s31415,periodic,250,31415,evolution/one-step,29.310482606498645 +periodic-n0250-s31415,periodic,250,31415,hitting-probability/cold-all-states,4.407950366141147 +periodic-n0250-s31415,periodic,250,31415,hitting-time/cold-all-states,9.376415896853109 +periodic-n0250-s31415,periodic,250,31415,power/10,4.863923399250012 +periodic-n0250-s31415,periodic,250,31415,power/100,4.098377105134121 +periodic-n0250-s31415,periodic,250,31415,power/2,6.352225665035911 +periodic-n0250-s31415,periodic,250,31415,stationary,1.1694714664398436 +periodic-n0250-s31415,periodic,250,31415,structure/classes-cold,15.117209689096875 +periodic-n0250-s31415,periodic,250,31415,structure/classes-lifecycle,10.293679406559294 +periodic-n0250-s31415,periodic,250,31415,structure/classes-warm/access,25.12631700264862 +periodic-n0250-s31415,periodic,250,31415,structure/classes-warm/consumed,10.778818625319897 +periodic-n0250-s31415,periodic,250,31415,structure/cyclic-classes-cold,272.49443317375085 +periodic-n0250-s31415,periodic,250,31415,structure/cyclic-classes-warm,0.8874434667263547 +periodic-n0250-s31415,periodic,250,31415,structure/irreducible-cold,29.529368521023343 +periodic-n0250-s31415,periodic,250,31415,structure/irreducible-warm,21.975490232856682 +periodic-n0250-s31415,periodic,250,31415,structure/period-cold,305.6133593135716 +periodic-n0250-s31415,periodic,250,31415,structure/period-warm,19.226496038826806 +periodic-n0500-s01729,periodic,500,1729,construction/public-consumed,7.37109776646296 +periodic-n0500-s01729,periodic,500,1729,evolution/k-10,3.474036424251007 +periodic-n0500-s01729,periodic,500,1729,evolution/k-100,1.4349783303857155 +periodic-n0500-s01729,periodic,500,1729,evolution/one-step,22.78609816682882 +periodic-n0500-s01729,periodic,500,1729,hitting-probability/cold-all-states,4.352480447544975 +periodic-n0500-s01729,periodic,500,1729,hitting-time/cold-all-states,9.291452001490669 +periodic-n0500-s01729,periodic,500,1729,power/10,3.7223290967567637 +periodic-n0500-s01729,periodic,500,1729,power/100,2.533369388775687 +periodic-n0500-s01729,periodic,500,1729,power/2,5.243668461737486 +periodic-n0500-s01729,periodic,500,1729,stationary,0.9137701760896946 +periodic-n0500-s01729,periodic,500,1729,structure/classes-cold,21.75504798515517 +periodic-n0500-s01729,periodic,500,1729,structure/classes-lifecycle,7.625807736894596 +periodic-n0500-s01729,periodic,500,1729,structure/classes-warm/access,25.010684490435718 +periodic-n0500-s01729,periodic,500,1729,structure/classes-warm/consumed,11.378623368877406 +periodic-n0500-s01729,periodic,500,1729,structure/cyclic-classes-cold,497.57534579969706 +periodic-n0500-s01729,periodic,500,1729,structure/cyclic-classes-warm,0.9243734823918037 +periodic-n0500-s01729,periodic,500,1729,structure/irreducible-cold,41.83957541359565 +periodic-n0500-s01729,periodic,500,1729,structure/irreducible-warm,22.43682572480075 +periodic-n0500-s01729,periodic,500,1729,structure/period-cold,518.1037655969321 +periodic-n0500-s01729,periodic,500,1729,structure/period-warm,18.97603850629958 +periodic-n0500-s02718,periodic,500,2718,construction/public-consumed,7.701723192950402 +periodic-n0500-s02718,periodic,500,2718,evolution/k-10,3.2397340335593388 +periodic-n0500-s02718,periodic,500,2718,evolution/k-100,1.370633907718095 +periodic-n0500-s02718,periodic,500,2718,evolution/one-step,21.30508541580444 +periodic-n0500-s02718,periodic,500,2718,hitting-probability/cold-all-states,4.614464998573955 +periodic-n0500-s02718,periodic,500,2718,hitting-time/cold-all-states,9.85447904710163 +periodic-n0500-s02718,periodic,500,2718,power/10,3.7101992476846593 +periodic-n0500-s02718,periodic,500,2718,power/100,2.492225688331176 +periodic-n0500-s02718,periodic,500,2718,power/2,5.302867567500859 +periodic-n0500-s02718,periodic,500,2718,stationary,0.9576292537786284 +periodic-n0500-s02718,periodic,500,2718,structure/classes-cold,21.53835290933595 +periodic-n0500-s02718,periodic,500,2718,structure/classes-lifecycle,7.674143992003149 +periodic-n0500-s02718,periodic,500,2718,structure/classes-warm/access,23.49591525258463 +periodic-n0500-s02718,periodic,500,2718,structure/classes-warm/consumed,11.348903743011041 +periodic-n0500-s02718,periodic,500,2718,structure/cyclic-classes-cold,501.2406260178599 +periodic-n0500-s02718,periodic,500,2718,structure/cyclic-classes-warm,0.926237941463265 +periodic-n0500-s02718,periodic,500,2718,structure/irreducible-cold,41.06692272602524 +periodic-n0500-s02718,periodic,500,2718,structure/irreducible-warm,23.417932942688495 +periodic-n0500-s02718,periodic,500,2718,structure/period-cold,521.0431599168202 +periodic-n0500-s02718,periodic,500,2718,structure/period-warm,19.63072422499655 +periodic-n0500-s31415,periodic,500,31415,construction/public-consumed,7.525023952271946 +periodic-n0500-s31415,periodic,500,31415,evolution/k-10,3.4355693648323147 +periodic-n0500-s31415,periodic,500,31415,evolution/k-100,1.3998225445493906 +periodic-n0500-s31415,periodic,500,31415,evolution/one-step,21.00909788235459 +periodic-n0500-s31415,periodic,500,31415,hitting-probability/cold-all-states,4.409802145335504 +periodic-n0500-s31415,periodic,500,31415,hitting-time/cold-all-states,9.519526343795512 +periodic-n0500-s31415,periodic,500,31415,power/10,3.680394992519896 +periodic-n0500-s31415,periodic,500,31415,power/100,2.497990191120638 +periodic-n0500-s31415,periodic,500,31415,power/2,5.204500718198526 +periodic-n0500-s31415,periodic,500,31415,stationary,0.9203435439510346 +periodic-n0500-s31415,periodic,500,31415,structure/classes-cold,21.2485003657722 +periodic-n0500-s31415,periodic,500,31415,structure/classes-lifecycle,7.5519266587634135 +periodic-n0500-s31415,periodic,500,31415,structure/classes-warm/access,24.69307232516706 +periodic-n0500-s31415,periodic,500,31415,structure/classes-warm/consumed,11.267107058305033 +periodic-n0500-s31415,periodic,500,31415,structure/cyclic-classes-cold,500.6991738174676 +periodic-n0500-s31415,periodic,500,31415,structure/cyclic-classes-warm,0.9275683225652424 +periodic-n0500-s31415,periodic,500,31415,structure/irreducible-cold,38.7043614539565 +periodic-n0500-s31415,periodic,500,31415,structure/irreducible-warm,22.7891040464629 +periodic-n0500-s31415,periodic,500,31415,structure/period-cold,511.2485501774983 +periodic-n0500-s31415,periodic,500,31415,structure/period-warm,19.34350024394425 +periodic-n1000-s01729,periodic,1000,1729,construction/public-consumed,6.769079930139255 +periodic-n1000-s01729,periodic,1000,1729,evolution/k-10,2.0258393625473876 +periodic-n1000-s01729,periodic,1000,1729,evolution/k-100,1.0631517807174997 +periodic-n1000-s01729,periodic,1000,1729,evolution/one-step,10.959766707014062 +periodic-n1000-s01729,periodic,1000,1729,structure/classes-cold,35.97493473729635 +periodic-n1000-s01729,periodic,1000,1729,structure/classes-lifecycle,6.719023259980693 +periodic-n1000-s01729,periodic,1000,1729,structure/classes-warm/access,25.271710614796433 +periodic-n1000-s01729,periodic,1000,1729,structure/classes-warm/consumed,11.617679949433397 +periodic-n1000-s01729,periodic,1000,1729,structure/cyclic-classes-cold,967.2263587390522 +periodic-n1000-s01729,periodic,1000,1729,structure/cyclic-classes-warm,0.9398638173541393 +periodic-n1000-s01729,periodic,1000,1729,structure/irreducible-cold,69.58734962368898 +periodic-n1000-s01729,periodic,1000,1729,structure/irreducible-warm,22.924048539235525 +periodic-n1000-s01729,periodic,1000,1729,structure/period-cold,1012.1783353026397 +periodic-n1000-s01729,periodic,1000,1729,structure/period-warm,19.378418035206167 +periodic-n1000-s02718,periodic,1000,2718,construction/public-consumed,6.818840260280536 +periodic-n1000-s02718,periodic,1000,2718,evolution/k-10,2.23757626296933 +periodic-n1000-s02718,periodic,1000,2718,evolution/k-100,1.1380564318809856 +periodic-n1000-s02718,periodic,1000,2718,evolution/one-step,11.325773711563743 +periodic-n1000-s02718,periodic,1000,2718,structure/classes-cold,36.5032472119531 +periodic-n1000-s02718,periodic,1000,2718,structure/classes-lifecycle,6.714430621558221 +periodic-n1000-s02718,periodic,1000,2718,structure/classes-warm/access,25.15901966642907 +periodic-n1000-s02718,periodic,1000,2718,structure/classes-warm/consumed,11.684749885510977 +periodic-n1000-s02718,periodic,1000,2718,structure/cyclic-classes-cold,965.6649447034634 +periodic-n1000-s02718,periodic,1000,2718,structure/cyclic-classes-warm,0.9389103546254827 +periodic-n1000-s02718,periodic,1000,2718,structure/irreducible-cold,69.42812314204471 +periodic-n1000-s02718,periodic,1000,2718,structure/irreducible-warm,23.091538926459872 +periodic-n1000-s02718,periodic,1000,2718,structure/period-cold,1013.1901287930459 +periodic-n1000-s02718,periodic,1000,2718,structure/period-warm,19.337214879930695 +periodic-n1000-s31415,periodic,1000,31415,construction/public-consumed,6.820592117486039 +periodic-n1000-s31415,periodic,1000,31415,evolution/k-10,2.0864317161362984 +periodic-n1000-s31415,periodic,1000,31415,evolution/k-100,1.0944008541335977 +periodic-n1000-s31415,periodic,1000,31415,evolution/one-step,10.84548836020236 +periodic-n1000-s31415,periodic,1000,31415,structure/classes-cold,36.12061304595555 +periodic-n1000-s31415,periodic,1000,31415,structure/classes-lifecycle,6.645012013297067 +periodic-n1000-s31415,periodic,1000,31415,structure/classes-warm/access,24.97101776241737 +periodic-n1000-s31415,periodic,1000,31415,structure/classes-warm/consumed,11.62203130323196 +periodic-n1000-s31415,periodic,1000,31415,structure/cyclic-classes-cold,969.9014282954292 +periodic-n1000-s31415,periodic,1000,31415,structure/cyclic-classes-warm,0.9374097785785652 +periodic-n1000-s31415,periodic,1000,31415,structure/irreducible-cold,68.95315949174226 +periodic-n1000-s31415,periodic,1000,31415,structure/irreducible-warm,22.9501914102406 +periodic-n1000-s31415,periodic,1000,31415,structure/period-cold,1017.8616271729484 +periodic-n1000-s31415,periodic,1000,31415,structure/period-warm,19.603803323389535 +reducible-n0010-s01729,reducible,10,1729,construction/public-consumed,57.07139575682687 +reducible-n0010-s01729,reducible,10,1729,evolution/k-10,31.91423074560955 +reducible-n0010-s01729,reducible,10,1729,evolution/k-100,85.07415134392352 +reducible-n0010-s01729,reducible,10,1729,evolution/one-step,121.89848201473528 +reducible-n0010-s01729,reducible,10,1729,finite-time/n-step/k-10,17.329940896803535 +reducible-n0010-s01729,reducible,10,1729,finite-time/n-step/k-100,14.988445700336328 +reducible-n0010-s01729,reducible,10,1729,finite-time/observation/k-10,14.951865205158118 +reducible-n0010-s01729,reducible,10,1729,finite-time/observation/k-100,14.338310299593513 +reducible-n0010-s01729,reducible,10,1729,finite-time/step,1.1539058518212897 +reducible-n0010-s01729,reducible,10,1729,hitting-probability/cold-all-states,2.9401276703091725 +reducible-n0010-s01729,reducible,10,1729,hitting-time/cold-all-states,16.074364723666474 +reducible-n0010-s01729,reducible,10,1729,hitting/bounded/at-most/k-10,13.419947719672864 +reducible-n0010-s01729,reducible,10,1729,hitting/bounded/at-most/k-100,18.025597362113828 +reducible-n0010-s01729,reducible,10,1729,hitting/bounded/exact/k-10,13.169268515099034 +reducible-n0010-s01729,reducible,10,1729,hitting/bounded/exact/k-100,18.35685093398399 +reducible-n0010-s01729,reducible,10,1729,hitting/bounded/greater-than/k-10,13.453891822261914 +reducible-n0010-s01729,reducible,10,1729,hitting/bounded/greater-than/k-100,17.91054111676924 +reducible-n0010-s01729,reducible,10,1729,occupation-matrix,28.492146543045287 +reducible-n0010-s01729,reducible,10,1729,power/10,69.42570409253405 +reducible-n0010-s01729,reducible,10,1729,power/100,54.465159046225374 +reducible-n0010-s01729,reducible,10,1729,power/2,90.27745148298408 +reducible-n0010-s01729,reducible,10,1729,return/bounded/k-10,14.835492485148103 +reducible-n0010-s01729,reducible,10,1729,return/bounded/k-100,18.37056942140311 +reducible-n0010-s01729,reducible,10,1729,stationary,15.535597631922718 +reducible-n0010-s01729,reducible,10,1729,structure/classes-cold,8.247227937874378 +reducible-n0010-s01729,reducible,10,1729,structure/classes-lifecycle,48.42248051632651 +reducible-n0010-s01729,reducible,10,1729,structure/classes-warm/access,25.603563388138085 +reducible-n0010-s01729,reducible,10,1729,structure/classes-warm/consumed,22.574683847027067 +reducible-n0010-s01729,reducible,10,1729,structure/irreducible-cold,11.827688064479421 +reducible-n0010-s01729,reducible,10,1729,structure/irreducible-warm,25.155848712891576 +reducible-n0010-s01729,reducible,10,1729,visits/bounded-expectation/k-10,3.871449263199117 +reducible-n0010-s01729,reducible,10,1729,visits/bounded-expectation/k-100,2.1121657928465924 +reducible-n0010-s02718,reducible,10,2718,construction/public-consumed,57.45224999230168 +reducible-n0010-s02718,reducible,10,2718,evolution/k-10,31.33913157077594 +reducible-n0010-s02718,reducible,10,2718,evolution/k-100,84.88033562252994 +reducible-n0010-s02718,reducible,10,2718,evolution/one-step,121.64144206321556 +reducible-n0010-s02718,reducible,10,2718,finite-time/n-step/k-10,17.707300462205808 +reducible-n0010-s02718,reducible,10,2718,finite-time/n-step/k-100,15.062018200287678 +reducible-n0010-s02718,reducible,10,2718,finite-time/observation/k-10,15.311901126724782 +reducible-n0010-s02718,reducible,10,2718,finite-time/observation/k-100,14.2466342728378 +reducible-n0010-s02718,reducible,10,2718,finite-time/step,1.158560034901611 +reducible-n0010-s02718,reducible,10,2718,hitting-probability/cold-all-states,2.9829173349003493 +reducible-n0010-s02718,reducible,10,2718,hitting-time/cold-all-states,16.4196891647393 +reducible-n0010-s02718,reducible,10,2718,hitting/bounded/at-most/k-10,13.350511388721529 +reducible-n0010-s02718,reducible,10,2718,hitting/bounded/at-most/k-100,18.038804208362276 +reducible-n0010-s02718,reducible,10,2718,hitting/bounded/exact/k-10,12.992941193203054 +reducible-n0010-s02718,reducible,10,2718,hitting/bounded/exact/k-100,18.136931924928746 +reducible-n0010-s02718,reducible,10,2718,hitting/bounded/greater-than/k-10,13.463136451488946 +reducible-n0010-s02718,reducible,10,2718,hitting/bounded/greater-than/k-100,18.535185330090307 +reducible-n0010-s02718,reducible,10,2718,occupation-matrix,28.5639018595422 +reducible-n0010-s02718,reducible,10,2718,power/10,70.03445317157731 +reducible-n0010-s02718,reducible,10,2718,power/100,56.595669207860595 +reducible-n0010-s02718,reducible,10,2718,power/2,90.82994980051836 +reducible-n0010-s02718,reducible,10,2718,return/bounded/k-10,14.610591869489811 +reducible-n0010-s02718,reducible,10,2718,return/bounded/k-100,18.942194049231553 +reducible-n0010-s02718,reducible,10,2718,stationary,15.047305231097662 +reducible-n0010-s02718,reducible,10,2718,structure/classes-cold,8.213893347013027 +reducible-n0010-s02718,reducible,10,2718,structure/classes-lifecycle,49.81682097505721 +reducible-n0010-s02718,reducible,10,2718,structure/classes-warm/access,25.36420575222952 +reducible-n0010-s02718,reducible,10,2718,structure/classes-warm/consumed,22.855777423477946 +reducible-n0010-s02718,reducible,10,2718,structure/irreducible-cold,11.494973889100399 +reducible-n0010-s02718,reducible,10,2718,structure/irreducible-warm,23.740406146321604 +reducible-n0010-s02718,reducible,10,2718,visits/bounded-expectation/k-10,3.8772889653960774 +reducible-n0010-s02718,reducible,10,2718,visits/bounded-expectation/k-100,2.125773776013471 +reducible-n0010-s31415,reducible,10,31415,construction/public-consumed,57.314356820881656 +reducible-n0010-s31415,reducible,10,31415,evolution/k-10,31.547039031160708 +reducible-n0010-s31415,reducible,10,31415,evolution/k-100,84.37882523230672 +reducible-n0010-s31415,reducible,10,31415,evolution/one-step,123.15822426676012 +reducible-n0010-s31415,reducible,10,31415,finite-time/n-step/k-10,16.9172654539259 +reducible-n0010-s31415,reducible,10,31415,finite-time/n-step/k-100,14.847081587174195 +reducible-n0010-s31415,reducible,10,31415,finite-time/observation/k-10,14.71416637820812 +reducible-n0010-s31415,reducible,10,31415,finite-time/observation/k-100,14.475489519085997 +reducible-n0010-s31415,reducible,10,31415,finite-time/step,1.1293063834072201 +reducible-n0010-s31415,reducible,10,31415,hitting-probability/cold-all-states,2.984022837430583 +reducible-n0010-s31415,reducible,10,31415,hitting-time/cold-all-states,16.31558109838882 +reducible-n0010-s31415,reducible,10,31415,hitting/bounded/at-most/k-10,13.025728837875246 +reducible-n0010-s31415,reducible,10,31415,hitting/bounded/at-most/k-100,17.817467922760724 +reducible-n0010-s31415,reducible,10,31415,hitting/bounded/exact/k-10,13.002200403127077 +reducible-n0010-s31415,reducible,10,31415,hitting/bounded/exact/k-100,18.186504590415062 +reducible-n0010-s31415,reducible,10,31415,hitting/bounded/greater-than/k-10,13.453547786391535 +reducible-n0010-s31415,reducible,10,31415,hitting/bounded/greater-than/k-100,18.04489553873661 +reducible-n0010-s31415,reducible,10,31415,occupation-matrix,28.62423351963627 +reducible-n0010-s31415,reducible,10,31415,power/10,70.36851758079598 +reducible-n0010-s31415,reducible,10,31415,power/100,54.4917328640181 +reducible-n0010-s31415,reducible,10,31415,power/2,91.4522067433977 +reducible-n0010-s31415,reducible,10,31415,return/bounded/k-10,14.473849867428614 +reducible-n0010-s31415,reducible,10,31415,return/bounded/k-100,18.296873771936763 +reducible-n0010-s31415,reducible,10,31415,stationary,14.927116724236518 +reducible-n0010-s31415,reducible,10,31415,structure/classes-cold,7.998095397562366 +reducible-n0010-s31415,reducible,10,31415,structure/classes-lifecycle,49.868307741777926 +reducible-n0010-s31415,reducible,10,31415,structure/classes-warm/access,23.37551130369571 +reducible-n0010-s31415,reducible,10,31415,structure/classes-warm/consumed,22.723389093559586 +reducible-n0010-s31415,reducible,10,31415,structure/irreducible-cold,11.779514660576615 +reducible-n0010-s31415,reducible,10,31415,structure/irreducible-warm,23.83346982694304 +reducible-n0010-s31415,reducible,10,31415,visits/bounded-expectation/k-10,3.8397869759431575 +reducible-n0010-s31415,reducible,10,31415,visits/bounded-expectation/k-100,2.144018109493355 +reducible-n0025-s01729,reducible,25,1729,construction/public-consumed,26.381007857605862 +reducible-n0025-s01729,reducible,25,1729,evolution/k-10,27.803141091824667 +reducible-n0025-s01729,reducible,25,1729,evolution/k-100,32.348502106939314 +reducible-n0025-s01729,reducible,25,1729,evolution/one-step,107.08104766805114 +reducible-n0025-s01729,reducible,25,1729,finite-time/n-step/k-10,17.11914401095123 +reducible-n0025-s01729,reducible,25,1729,finite-time/n-step/k-100,11.456274441297127 +reducible-n0025-s01729,reducible,25,1729,finite-time/observation/k-10,14.109618448827007 +reducible-n0025-s01729,reducible,25,1729,finite-time/observation/k-100,11.213823683750219 +reducible-n0025-s01729,reducible,25,1729,finite-time/step,1.5749144512743452 +reducible-n0025-s01729,reducible,25,1729,hitting-probability/cold-all-states,1.6796685766869714 +reducible-n0025-s01729,reducible,25,1729,hitting-time/cold-all-states,6.09943097593387 +reducible-n0025-s01729,reducible,25,1729,hitting/bounded/at-most/k-10,14.247125573387704 +reducible-n0025-s01729,reducible,25,1729,hitting/bounded/at-most/k-100,20.97686306678311 +reducible-n0025-s01729,reducible,25,1729,hitting/bounded/exact/k-10,14.049985346368164 +reducible-n0025-s01729,reducible,25,1729,hitting/bounded/exact/k-100,20.825935857223456 +reducible-n0025-s01729,reducible,25,1729,hitting/bounded/greater-than/k-10,14.356803946394342 +reducible-n0025-s01729,reducible,25,1729,hitting/bounded/greater-than/k-100,21.484576990542372 +reducible-n0025-s01729,reducible,25,1729,occupation-matrix,28.185539877414868 +reducible-n0025-s01729,reducible,25,1729,power/10,31.74707141122342 +reducible-n0025-s01729,reducible,25,1729,power/100,25.88929675470737 +reducible-n0025-s01729,reducible,25,1729,power/2,39.43673598192473 +reducible-n0025-s01729,reducible,25,1729,return/bounded/k-10,16.321191006704794 +reducible-n0025-s01729,reducible,25,1729,return/bounded/k-100,22.183974175787426 +reducible-n0025-s01729,reducible,25,1729,stationary,20.944371447799753 +reducible-n0025-s01729,reducible,25,1729,structure/classes-cold,11.72242729197371 +reducible-n0025-s01729,reducible,25,1729,structure/classes-lifecycle,23.608530483041196 +reducible-n0025-s01729,reducible,25,1729,structure/classes-warm/access,25.415136048438583 +reducible-n0025-s01729,reducible,25,1729,structure/classes-warm/consumed,15.85284607949212 +reducible-n0025-s01729,reducible,25,1729,structure/irreducible-cold,15.339271247807387 +reducible-n0025-s01729,reducible,25,1729,structure/irreducible-warm,23.795585099622535 +reducible-n0025-s01729,reducible,25,1729,visits/bounded-expectation/k-10,5.227023610326795 +reducible-n0025-s01729,reducible,25,1729,visits/bounded-expectation/k-100,2.1912654521890502 +reducible-n0025-s02718,reducible,25,2718,construction/public-consumed,26.357176691098218 +reducible-n0025-s02718,reducible,25,2718,evolution/k-10,28.031848486630476 +reducible-n0025-s02718,reducible,25,2718,evolution/k-100,32.48754358417514 +reducible-n0025-s02718,reducible,25,2718,evolution/one-step,108.36674235011729 +reducible-n0025-s02718,reducible,25,2718,finite-time/n-step/k-10,16.56385697471394 +reducible-n0025-s02718,reducible,25,2718,finite-time/n-step/k-100,11.482876501844947 +reducible-n0025-s02718,reducible,25,2718,finite-time/observation/k-10,14.011162880110636 +reducible-n0025-s02718,reducible,25,2718,finite-time/observation/k-100,11.177682941229223 +reducible-n0025-s02718,reducible,25,2718,finite-time/step,1.5632248586173647 +reducible-n0025-s02718,reducible,25,2718,hitting-probability/cold-all-states,1.697280392512117 +reducible-n0025-s02718,reducible,25,2718,hitting-time/cold-all-states,6.097691142837171 +reducible-n0025-s02718,reducible,25,2718,hitting/bounded/at-most/k-10,13.859923300557588 +reducible-n0025-s02718,reducible,25,2718,hitting/bounded/at-most/k-100,20.06282529436679 +reducible-n0025-s02718,reducible,25,2718,hitting/bounded/exact/k-10,13.962389616171214 +reducible-n0025-s02718,reducible,25,2718,hitting/bounded/exact/k-100,20.97004023318638 +reducible-n0025-s02718,reducible,25,2718,hitting/bounded/greater-than/k-10,14.018607872487825 +reducible-n0025-s02718,reducible,25,2718,hitting/bounded/greater-than/k-100,20.109939286646824 +reducible-n0025-s02718,reducible,25,2718,occupation-matrix,28.470875186105467 +reducible-n0025-s02718,reducible,25,2718,power/10,31.4981329651127 +reducible-n0025-s02718,reducible,25,2718,power/100,26.36360104475963 +reducible-n0025-s02718,reducible,25,2718,power/2,38.54197543359135 +reducible-n0025-s02718,reducible,25,2718,return/bounded/k-10,15.751131454150254 +reducible-n0025-s02718,reducible,25,2718,return/bounded/k-100,20.352065367370987 +reducible-n0025-s02718,reducible,25,2718,stationary,20.913400603880184 +reducible-n0025-s02718,reducible,25,2718,structure/classes-cold,12.05996483532534 +reducible-n0025-s02718,reducible,25,2718,structure/classes-lifecycle,23.41785018384238 +reducible-n0025-s02718,reducible,25,2718,structure/classes-warm/access,25.116090329483136 +reducible-n0025-s02718,reducible,25,2718,structure/classes-warm/consumed,15.80282881693885 +reducible-n0025-s02718,reducible,25,2718,structure/irreducible-cold,14.824081812073624 +reducible-n0025-s02718,reducible,25,2718,structure/irreducible-warm,23.738520281726654 +reducible-n0025-s02718,reducible,25,2718,visits/bounded-expectation/k-10,4.886918478901888 +reducible-n0025-s02718,reducible,25,2718,visits/bounded-expectation/k-100,2.1947018358345094 +reducible-n0025-s31415,reducible,25,31415,construction/public-consumed,26.3451842967052 +reducible-n0025-s31415,reducible,25,31415,evolution/k-10,27.891657759051594 +reducible-n0025-s31415,reducible,25,31415,evolution/k-100,32.728381177102186 +reducible-n0025-s31415,reducible,25,31415,evolution/one-step,111.49671024667472 +reducible-n0025-s31415,reducible,25,31415,finite-time/n-step/k-10,17.153045743368523 +reducible-n0025-s31415,reducible,25,31415,finite-time/n-step/k-100,11.417011115038456 +reducible-n0025-s31415,reducible,25,31415,finite-time/observation/k-10,14.28253007220505 +reducible-n0025-s31415,reducible,25,31415,finite-time/observation/k-100,11.268100553221492 +reducible-n0025-s31415,reducible,25,31415,finite-time/step,1.5493211961143787 +reducible-n0025-s31415,reducible,25,31415,hitting-probability/cold-all-states,1.74740576556614 +reducible-n0025-s31415,reducible,25,31415,hitting-time/cold-all-states,6.287736867654802 +reducible-n0025-s31415,reducible,25,31415,hitting/bounded/at-most/k-10,14.620463724835156 +reducible-n0025-s31415,reducible,25,31415,hitting/bounded/at-most/k-100,22.129965629229936 +reducible-n0025-s31415,reducible,25,31415,hitting/bounded/exact/k-10,14.59868045859145 +reducible-n0025-s31415,reducible,25,31415,hitting/bounded/exact/k-100,20.20946937694428 +reducible-n0025-s31415,reducible,25,31415,hitting/bounded/greater-than/k-10,14.282647705284447 +reducible-n0025-s31415,reducible,25,31415,hitting/bounded/greater-than/k-100,20.290589543019777 +reducible-n0025-s31415,reducible,25,31415,occupation-matrix,28.537193977636186 +reducible-n0025-s31415,reducible,25,31415,power/10,36.243484406840956 +reducible-n0025-s31415,reducible,25,31415,power/100,27.118893109421727 +reducible-n0025-s31415,reducible,25,31415,power/2,40.55077288642275 +reducible-n0025-s31415,reducible,25,31415,return/bounded/k-10,16.561798922753432 +reducible-n0025-s31415,reducible,25,31415,return/bounded/k-100,20.40242472683203 +reducible-n0025-s31415,reducible,25,31415,stationary,20.830408508608496 +reducible-n0025-s31415,reducible,25,31415,structure/classes-cold,13.169210164323156 +reducible-n0025-s31415,reducible,25,31415,structure/classes-lifecycle,23.115576493547398 +reducible-n0025-s31415,reducible,25,31415,structure/classes-warm/access,25.80868508336644 +reducible-n0025-s31415,reducible,25,31415,structure/classes-warm/consumed,15.918475507628159 +reducible-n0025-s31415,reducible,25,31415,structure/irreducible-cold,15.91589322835111 +reducible-n0025-s31415,reducible,25,31415,structure/irreducible-warm,23.85558987110716 +reducible-n0025-s31415,reducible,25,31415,visits/bounded-expectation/k-10,5.009113843514019 +reducible-n0025-s31415,reducible,25,31415,visits/bounded-expectation/k-100,2.2342039991460156 +reducible-n0050-s01729,reducible,50,1729,construction/public-consumed,20.920208403026663 +reducible-n0050-s01729,reducible,50,1729,evolution/k-10,20.153054559328364 +reducible-n0050-s01729,reducible,50,1729,evolution/k-100,15.50873032273386 +reducible-n0050-s01729,reducible,50,1729,evolution/one-step,84.67560921112383 +reducible-n0050-s01729,reducible,50,1729,finite-time/n-step/k-10,14.838720263410664 +reducible-n0050-s01729,reducible,50,1729,finite-time/n-step/k-100,7.314601629495306 +reducible-n0050-s01729,reducible,50,1729,finite-time/observation/k-10,11.893808427879998 +reducible-n0050-s01729,reducible,50,1729,finite-time/observation/k-100,7.149161907646442 +reducible-n0050-s01729,reducible,50,1729,finite-time/step,1.9267490521083674 +reducible-n0050-s01729,reducible,50,1729,hitting-probability/cold-all-states,1.4967795034404752 +reducible-n0050-s01729,reducible,50,1729,hitting-time/cold-all-states,3.7874431709623635 +reducible-n0050-s01729,reducible,50,1729,hitting/bounded/at-most/k-10,20.629474806128453 +reducible-n0050-s01729,reducible,50,1729,hitting/bounded/at-most/k-100,17.020045254504954 +reducible-n0050-s01729,reducible,50,1729,hitting/bounded/exact/k-10,11.629871120916611 +reducible-n0050-s01729,reducible,50,1729,hitting/bounded/exact/k-100,17.181131498321925 +reducible-n0050-s01729,reducible,50,1729,hitting/bounded/greater-than/k-10,11.769474466862226 +reducible-n0050-s01729,reducible,50,1729,hitting/bounded/greater-than/k-100,16.997600183445996 +reducible-n0050-s01729,reducible,50,1729,occupation-matrix,35.9809842788031 +reducible-n0050-s01729,reducible,50,1729,power/10,26.504157748415977 +reducible-n0050-s01729,reducible,50,1729,power/100,22.077410984723546 +reducible-n0050-s01729,reducible,50,1729,power/2,27.87545424667994 +reducible-n0050-s01729,reducible,50,1729,return/bounded/k-10,14.870489142331696 +reducible-n0050-s01729,reducible,50,1729,return/bounded/k-100,17.577110392789397 +reducible-n0050-s01729,reducible,50,1729,stationary,24.04189071117228 +reducible-n0050-s01729,reducible,50,1729,structure/classes-cold,12.8261029015618 +reducible-n0050-s01729,reducible,50,1729,structure/classes-lifecycle,18.311176511516667 +reducible-n0050-s01729,reducible,50,1729,structure/classes-warm/access,25.22002314631249 +reducible-n0050-s01729,reducible,50,1729,structure/classes-warm/consumed,12.977414288220814 +reducible-n0050-s01729,reducible,50,1729,structure/irreducible-cold,15.30089752646157 +reducible-n0050-s01729,reducible,50,1729,structure/irreducible-warm,24.22696454966626 +reducible-n0050-s01729,reducible,50,1729,visits/bounded-expectation/k-10,6.276987409901661 +reducible-n0050-s01729,reducible,50,1729,visits/bounded-expectation/k-100,2.0707712194654224 +reducible-n0050-s02718,reducible,50,2718,construction/public-consumed,20.298847483053024 +reducible-n0050-s02718,reducible,50,2718,evolution/k-10,19.369544472446666 +reducible-n0050-s02718,reducible,50,2718,evolution/k-100,15.381582773481721 +reducible-n0050-s02718,reducible,50,2718,evolution/one-step,92.43873531763604 +reducible-n0050-s02718,reducible,50,2718,finite-time/n-step/k-10,15.262037175529962 +reducible-n0050-s02718,reducible,50,2718,finite-time/n-step/k-100,7.343496126220264 +reducible-n0050-s02718,reducible,50,2718,finite-time/observation/k-10,12.002983788561373 +reducible-n0050-s02718,reducible,50,2718,finite-time/observation/k-100,7.18901514293235 +reducible-n0050-s02718,reducible,50,2718,finite-time/step,2.1841724937026252 +reducible-n0050-s02718,reducible,50,2718,hitting-probability/cold-all-states,1.7664910600181025 +reducible-n0050-s02718,reducible,50,2718,hitting-time/cold-all-states,3.857587604492423 +reducible-n0050-s02718,reducible,50,2718,hitting/bounded/at-most/k-10,11.8876581753756 +reducible-n0050-s02718,reducible,50,2718,hitting/bounded/at-most/k-100,17.086826250835195 +reducible-n0050-s02718,reducible,50,2718,hitting/bounded/exact/k-10,11.65473013565086 +reducible-n0050-s02718,reducible,50,2718,hitting/bounded/exact/k-100,17.033483257966736 +reducible-n0050-s02718,reducible,50,2718,hitting/bounded/greater-than/k-10,11.747156076318406 +reducible-n0050-s02718,reducible,50,2718,hitting/bounded/greater-than/k-100,17.092856838389114 +reducible-n0050-s02718,reducible,50,2718,occupation-matrix,34.23901995286662 +reducible-n0050-s02718,reducible,50,2718,power/10,26.452533523793033 +reducible-n0050-s02718,reducible,50,2718,power/100,22.280882455898343 +reducible-n0050-s02718,reducible,50,2718,power/2,29.475809750469658 +reducible-n0050-s02718,reducible,50,2718,return/bounded/k-10,14.080488164937055 +reducible-n0050-s02718,reducible,50,2718,return/bounded/k-100,18.799856379755404 +reducible-n0050-s02718,reducible,50,2718,stationary,23.167254319718626 +reducible-n0050-s02718,reducible,50,2718,structure/classes-cold,13.037261520019452 +reducible-n0050-s02718,reducible,50,2718,structure/classes-lifecycle,18.518241731163545 +reducible-n0050-s02718,reducible,50,2718,structure/classes-warm/access,24.00745254281556 +reducible-n0050-s02718,reducible,50,2718,structure/classes-warm/consumed,12.980015075670716 +reducible-n0050-s02718,reducible,50,2718,structure/irreducible-cold,15.520755314731609 +reducible-n0050-s02718,reducible,50,2718,structure/irreducible-warm,21.83254602442669 +reducible-n0050-s02718,reducible,50,2718,visits/bounded-expectation/k-10,6.226586655305317 +reducible-n0050-s02718,reducible,50,2718,visits/bounded-expectation/k-100,2.153320936430698 +reducible-n0050-s31415,reducible,50,31415,construction/public-consumed,20.827262752479974 +reducible-n0050-s31415,reducible,50,31415,evolution/k-10,20.030135493000344 +reducible-n0050-s31415,reducible,50,31415,evolution/k-100,15.489005799822557 +reducible-n0050-s31415,reducible,50,31415,evolution/one-step,82.46059206635242 +reducible-n0050-s31415,reducible,50,31415,finite-time/n-step/k-10,14.866914114478746 +reducible-n0050-s31415,reducible,50,31415,finite-time/n-step/k-100,7.269914329631152 +reducible-n0050-s31415,reducible,50,31415,finite-time/observation/k-10,12.084917703980283 +reducible-n0050-s31415,reducible,50,31415,finite-time/observation/k-100,7.098390184553729 +reducible-n0050-s31415,reducible,50,31415,finite-time/step,1.9357053016338006 +reducible-n0050-s31415,reducible,50,31415,hitting-probability/cold-all-states,1.4767336395898578 +reducible-n0050-s31415,reducible,50,31415,hitting-time/cold-all-states,3.8020217113222152 +reducible-n0050-s31415,reducible,50,31415,hitting/bounded/at-most/k-10,11.74242796059937 +reducible-n0050-s31415,reducible,50,31415,hitting/bounded/at-most/k-100,17.05236057487154 +reducible-n0050-s31415,reducible,50,31415,hitting/bounded/exact/k-10,11.657449279071031 +reducible-n0050-s31415,reducible,50,31415,hitting/bounded/exact/k-100,17.062143144763148 +reducible-n0050-s31415,reducible,50,31415,hitting/bounded/greater-than/k-10,11.55470274748974 +reducible-n0050-s31415,reducible,50,31415,hitting/bounded/greater-than/k-100,17.069999287961732 +reducible-n0050-s31415,reducible,50,31415,occupation-matrix,33.93535541733749 +reducible-n0050-s31415,reducible,50,31415,power/10,25.865331575004063 +reducible-n0050-s31415,reducible,50,31415,power/100,21.522648525065296 +reducible-n0050-s31415,reducible,50,31415,power/2,27.51505319740882 +reducible-n0050-s31415,reducible,50,31415,return/bounded/k-10,14.729431201105866 +reducible-n0050-s31415,reducible,50,31415,return/bounded/k-100,17.58569400050675 +reducible-n0050-s31415,reducible,50,31415,stationary,23.0337607195079 +reducible-n0050-s31415,reducible,50,31415,structure/classes-cold,12.354136897766391 +reducible-n0050-s31415,reducible,50,31415,structure/classes-lifecycle,18.170800412129868 +reducible-n0050-s31415,reducible,50,31415,structure/classes-warm/access,24.561991827776616 +reducible-n0050-s31415,reducible,50,31415,structure/classes-warm/consumed,12.702699361089055 +reducible-n0050-s31415,reducible,50,31415,structure/irreducible-cold,14.879288130513384 +reducible-n0050-s31415,reducible,50,31415,structure/irreducible-warm,23.502866085023115 +reducible-n0050-s31415,reducible,50,31415,visits/bounded-expectation/k-10,6.2172262847802555 +reducible-n0050-s31415,reducible,50,31415,visits/bounded-expectation/k-100,2.0013305532055257 +reducible-n0100-s01729,reducible,100,1729,construction/public-consumed,19.381552124886213 +reducible-n0100-s01729,reducible,100,1729,evolution/k-10,13.779391439708155 +reducible-n0100-s01729,reducible,100,1729,evolution/k-100,4.660119713801407 +reducible-n0100-s01729,reducible,100,1729,evolution/one-step,67.98227201706516 +reducible-n0100-s01729,reducible,100,1729,finite-time/n-step/k-10,11.278915956700343 +reducible-n0100-s01729,reducible,100,1729,finite-time/n-step/k-100,4.523724797265196 +reducible-n0100-s01729,reducible,100,1729,finite-time/observation/k-10,9.55106190248719 +reducible-n0100-s01729,reducible,100,1729,finite-time/observation/k-100,4.3487825777891285 +reducible-n0100-s01729,reducible,100,1729,finite-time/step,3.4287946053254648 +reducible-n0100-s01729,reducible,100,1729,hitting-probability/cold-all-states,1.8941235735796267 +reducible-n0100-s01729,reducible,100,1729,hitting-time/cold-all-states,3.5601029061707035 +reducible-n0100-s01729,reducible,100,1729,hitting/bounded/at-most/k-10,9.605715995999569 +reducible-n0100-s01729,reducible,100,1729,hitting/bounded/at-most/k-100,15.934529564014817 +reducible-n0100-s01729,reducible,100,1729,hitting/bounded/exact/k-10,9.687631735433445 +reducible-n0100-s01729,reducible,100,1729,hitting/bounded/exact/k-100,16.073816465259963 +reducible-n0100-s01729,reducible,100,1729,hitting/bounded/greater-than/k-10,9.6422484104744 +reducible-n0100-s01729,reducible,100,1729,hitting/bounded/greater-than/k-100,16.05844478271325 +reducible-n0100-s01729,reducible,100,1729,occupation-matrix,31.483441568316753 +reducible-n0100-s01729,reducible,100,1729,power/10,24.953281681903718 +reducible-n0100-s01729,reducible,100,1729,power/100,19.992281019450918 +reducible-n0100-s01729,reducible,100,1729,power/2,26.419872478081984 +reducible-n0100-s01729,reducible,100,1729,return/bounded/k-10,13.983633362865305 +reducible-n0100-s01729,reducible,100,1729,return/bounded/k-100,16.768534777795008 +reducible-n0100-s01729,reducible,100,1729,stationary,24.251052460760725 +reducible-n0100-s01729,reducible,100,1729,structure/classes-cold,13.172085015848191 +reducible-n0100-s01729,reducible,100,1729,structure/classes-lifecycle,16.133432619832647 +reducible-n0100-s01729,reducible,100,1729,structure/classes-warm/access,25.24520347217544 +reducible-n0100-s01729,reducible,100,1729,structure/classes-warm/consumed,11.461263949000632 +reducible-n0100-s01729,reducible,100,1729,structure/irreducible-cold,14.392070825102952 +reducible-n0100-s01729,reducible,100,1729,structure/irreducible-warm,23.907491401014553 +reducible-n0100-s01729,reducible,100,1729,visits/bounded-expectation/k-10,6.322488107654007 +reducible-n0100-s01729,reducible,100,1729,visits/bounded-expectation/k-100,1.8162050611522556 +reducible-n0100-s02718,reducible,100,2718,construction/public-consumed,19.628251198412347 +reducible-n0100-s02718,reducible,100,2718,evolution/k-10,15.708754870832205 +reducible-n0100-s02718,reducible,100,2718,evolution/k-100,4.594203115141249 +reducible-n0100-s02718,reducible,100,2718,evolution/one-step,77.84749882320604 +reducible-n0100-s02718,reducible,100,2718,finite-time/n-step/k-10,12.611247316020439 +reducible-n0100-s02718,reducible,100,2718,finite-time/n-step/k-100,5.121241528877919 +reducible-n0100-s02718,reducible,100,2718,finite-time/observation/k-10,11.262310351070925 +reducible-n0100-s02718,reducible,100,2718,finite-time/observation/k-100,4.685250991399412 +reducible-n0100-s02718,reducible,100,2718,finite-time/step,6.873327619624457 +reducible-n0100-s02718,reducible,100,2718,hitting-probability/cold-all-states,2.096340780434679 +reducible-n0100-s02718,reducible,100,2718,hitting-time/cold-all-states,3.884197913839694 +reducible-n0100-s02718,reducible,100,2718,hitting/bounded/at-most/k-10,10.062526126176706 +reducible-n0100-s02718,reducible,100,2718,hitting/bounded/at-most/k-100,16.194573397549938 +reducible-n0100-s02718,reducible,100,2718,hitting/bounded/exact/k-10,11.33148985846152 +reducible-n0100-s02718,reducible,100,2718,hitting/bounded/exact/k-100,16.73579630535169 +reducible-n0100-s02718,reducible,100,2718,hitting/bounded/greater-than/k-10,11.026650758621852 +reducible-n0100-s02718,reducible,100,2718,hitting/bounded/greater-than/k-100,15.777525294144244 +reducible-n0100-s02718,reducible,100,2718,occupation-matrix,31.49516306170555 +reducible-n0100-s02718,reducible,100,2718,power/10,25.77701043267526 +reducible-n0100-s02718,reducible,100,2718,power/100,20.739364875762373 +reducible-n0100-s02718,reducible,100,2718,power/2,27.047772028810687 +reducible-n0100-s02718,reducible,100,2718,return/bounded/k-10,17.324068213811337 +reducible-n0100-s02718,reducible,100,2718,return/bounded/k-100,16.836187174138075 +reducible-n0100-s02718,reducible,100,2718,stationary,24.587559050851386 +reducible-n0100-s02718,reducible,100,2718,structure/classes-cold,13.725938419601029 +reducible-n0100-s02718,reducible,100,2718,structure/classes-lifecycle,16.384589289615874 +reducible-n0100-s02718,reducible,100,2718,structure/classes-warm/access,25.092634752472886 +reducible-n0100-s02718,reducible,100,2718,structure/classes-warm/consumed,11.556665168631664 +reducible-n0100-s02718,reducible,100,2718,structure/irreducible-cold,14.795072809646388 +reducible-n0100-s02718,reducible,100,2718,structure/irreducible-warm,25.938008496194108 +reducible-n0100-s02718,reducible,100,2718,visits/bounded-expectation/k-10,6.018439596175496 +reducible-n0100-s02718,reducible,100,2718,visits/bounded-expectation/k-100,1.922378952364169 +reducible-n0100-s31415,reducible,100,31415,construction/public-consumed,19.10616674640282 +reducible-n0100-s31415,reducible,100,31415,evolution/k-10,13.639686061077766 +reducible-n0100-s31415,reducible,100,31415,evolution/k-100,4.638883403351588 +reducible-n0100-s31415,reducible,100,31415,evolution/one-step,66.86911470013565 +reducible-n0100-s31415,reducible,100,31415,finite-time/n-step/k-10,11.450984303259395 +reducible-n0100-s31415,reducible,100,31415,finite-time/n-step/k-100,4.5481767341222685 +reducible-n0100-s31415,reducible,100,31415,finite-time/observation/k-10,13.536804047032952 +reducible-n0100-s31415,reducible,100,31415,finite-time/observation/k-100,4.373487274589755 +reducible-n0100-s31415,reducible,100,31415,finite-time/step,2.524223131409796 +reducible-n0100-s31415,reducible,100,31415,hitting-probability/cold-all-states,1.8304870371052788 +reducible-n0100-s31415,reducible,100,31415,hitting-time/cold-all-states,3.53903723186052 +reducible-n0100-s31415,reducible,100,31415,hitting/bounded/at-most/k-10,9.491421789951778 +reducible-n0100-s31415,reducible,100,31415,hitting/bounded/at-most/k-100,15.816495546563203 +reducible-n0100-s31415,reducible,100,31415,hitting/bounded/exact/k-10,9.699932639253095 +reducible-n0100-s31415,reducible,100,31415,hitting/bounded/exact/k-100,16.074404558324247 +reducible-n0100-s31415,reducible,100,31415,hitting/bounded/greater-than/k-10,8.992432438801712 +reducible-n0100-s31415,reducible,100,31415,hitting/bounded/greater-than/k-100,16.013248860483085 +reducible-n0100-s31415,reducible,100,31415,occupation-matrix,30.437584659271494 +reducible-n0100-s31415,reducible,100,31415,power/10,24.511536454129885 +reducible-n0100-s31415,reducible,100,31415,power/100,19.019767190909363 +reducible-n0100-s31415,reducible,100,31415,power/2,26.24743557811559 +reducible-n0100-s31415,reducible,100,31415,return/bounded/k-10,14.12431813488494 +reducible-n0100-s31415,reducible,100,31415,return/bounded/k-100,16.835671058163303 +reducible-n0100-s31415,reducible,100,31415,stationary,23.60229523808993 +reducible-n0100-s31415,reducible,100,31415,structure/classes-cold,13.154220191770124 +reducible-n0100-s31415,reducible,100,31415,structure/classes-lifecycle,15.643214501142165 +reducible-n0100-s31415,reducible,100,31415,structure/classes-warm/access,24.105136808188927 +reducible-n0100-s31415,reducible,100,31415,structure/classes-warm/consumed,11.438240066393 +reducible-n0100-s31415,reducible,100,31415,structure/irreducible-cold,15.080385558818008 +reducible-n0100-s31415,reducible,100,31415,structure/irreducible-warm,23.67563893667323 +reducible-n0100-s31415,reducible,100,31415,visits/bounded-expectation/k-10,6.491637452517361 +reducible-n0100-s31415,reducible,100,31415,visits/bounded-expectation/k-100,1.8276155957752203 +reducible-n0250-s01729,reducible,250,1729,construction/public-consumed,13.742592984792278 +reducible-n0250-s01729,reducible,250,1729,evolution/k-10,4.981991676677521 +reducible-n0250-s01729,reducible,250,1729,evolution/k-100,1.7437790003381604 +reducible-n0250-s01729,reducible,250,1729,evolution/one-step,31.592963002193027 +reducible-n0250-s01729,reducible,250,1729,hitting-probability/cold-all-states,3.348540567812139 +reducible-n0250-s01729,reducible,250,1729,hitting-time/cold-all-states,4.672393436375036 +reducible-n0250-s01729,reducible,250,1729,occupation-matrix,34.82507723981079 +reducible-n0250-s01729,reducible,250,1729,power/10,19.660425569703868 +reducible-n0250-s01729,reducible,250,1729,power/100,15.763678335503593 +reducible-n0250-s01729,reducible,250,1729,power/2,25.53795681512785 +reducible-n0250-s01729,reducible,250,1729,stationary,22.24052633187675 +reducible-n0250-s01729,reducible,250,1729,structure/classes-cold,12.631241243204098 +reducible-n0250-s01729,reducible,250,1729,structure/classes-lifecycle,10.608058139935263 +reducible-n0250-s01729,reducible,250,1729,structure/classes-warm/access,25.426521886894587 +reducible-n0250-s01729,reducible,250,1729,structure/classes-warm/consumed,10.717811020038484 +reducible-n0250-s01729,reducible,250,1729,structure/irreducible-cold,12.916162199830385 +reducible-n0250-s01729,reducible,250,1729,structure/irreducible-warm,23.395415933536082 +reducible-n0250-s02718,reducible,250,2718,construction/public-consumed,13.440836077125377 +reducible-n0250-s02718,reducible,250,2718,evolution/k-10,5.03841054091075 +reducible-n0250-s02718,reducible,250,2718,evolution/k-100,1.7480465209839593 +reducible-n0250-s02718,reducible,250,2718,evolution/one-step,31.795130427878785 +reducible-n0250-s02718,reducible,250,2718,hitting-probability/cold-all-states,3.329681813747474 +reducible-n0250-s02718,reducible,250,2718,hitting-time/cold-all-states,4.6233826236516755 +reducible-n0250-s02718,reducible,250,2718,occupation-matrix,34.4829748142274 +reducible-n0250-s02718,reducible,250,2718,power/10,18.04500000269824 +reducible-n0250-s02718,reducible,250,2718,power/100,15.870212789796607 +reducible-n0250-s02718,reducible,250,2718,power/2,25.581311380458303 +reducible-n0250-s02718,reducible,250,2718,stationary,22.11803067040181 +reducible-n0250-s02718,reducible,250,2718,structure/classes-cold,12.577133517127454 +reducible-n0250-s02718,reducible,250,2718,structure/classes-lifecycle,10.77545069174297 +reducible-n0250-s02718,reducible,250,2718,structure/classes-warm/access,25.112076018672383 +reducible-n0250-s02718,reducible,250,2718,structure/classes-warm/consumed,10.796519094437196 +reducible-n0250-s02718,reducible,250,2718,structure/irreducible-cold,13.037715613721025 +reducible-n0250-s02718,reducible,250,2718,structure/irreducible-warm,23.439460650596473 +reducible-n0250-s31415,reducible,250,31415,construction/public-consumed,13.246987442709997 +reducible-n0250-s31415,reducible,250,31415,evolution/k-10,5.150900511740963 +reducible-n0250-s31415,reducible,250,31415,evolution/k-100,1.747997641404126 +reducible-n0250-s31415,reducible,250,31415,evolution/one-step,32.8619595805185 +reducible-n0250-s31415,reducible,250,31415,hitting-probability/cold-all-states,3.3279488847289462 +reducible-n0250-s31415,reducible,250,31415,hitting-time/cold-all-states,4.660237937613108 +reducible-n0250-s31415,reducible,250,31415,occupation-matrix,32.48165615405256 +reducible-n0250-s31415,reducible,250,31415,power/10,19.61542531068868 +reducible-n0250-s31415,reducible,250,31415,power/100,15.92585838656129 +reducible-n0250-s31415,reducible,250,31415,power/2,25.571981560470576 +reducible-n0250-s31415,reducible,250,31415,stationary,22.10933145363127 +reducible-n0250-s31415,reducible,250,31415,structure/classes-cold,12.69565489416095 +reducible-n0250-s31415,reducible,250,31415,structure/classes-lifecycle,10.673484965118691 +reducible-n0250-s31415,reducible,250,31415,structure/classes-warm/access,23.27334627972613 +reducible-n0250-s31415,reducible,250,31415,structure/classes-warm/consumed,10.835632248918571 +reducible-n0250-s31415,reducible,250,31415,structure/irreducible-cold,12.995005457480255 +reducible-n0250-s31415,reducible,250,31415,structure/irreducible-warm,23.539452090291316 +reducible-n0500-s01729,reducible,500,1729,construction/public-consumed,10.000113024132135 +reducible-n0500-s01729,reducible,500,1729,evolution/k-10,3.4548952712150003 +reducible-n0500-s01729,reducible,500,1729,evolution/k-100,1.4012982391578208 +reducible-n0500-s01729,reducible,500,1729,evolution/one-step,21.92519052413097 +reducible-n0500-s01729,reducible,500,1729,hitting-probability/cold-all-states,3.753334919264832 +reducible-n0500-s01729,reducible,500,1729,hitting-time/cold-all-states,5.257589200001232 +reducible-n0500-s01729,reducible,500,1729,power/10,13.406505494658582 +reducible-n0500-s01729,reducible,500,1729,power/100,9.602696675402852 +reducible-n0500-s01729,reducible,500,1729,power/2,19.966857651167892 +reducible-n0500-s01729,reducible,500,1729,stationary,18.71491476916119 +reducible-n0500-s01729,reducible,500,1729,structure/classes-cold,10.466644869967219 +reducible-n0500-s01729,reducible,500,1729,structure/classes-lifecycle,8.139277836537252 +reducible-n0500-s01729,reducible,500,1729,structure/classes-warm/access,24.87380500459497 +reducible-n0500-s01729,reducible,500,1729,structure/classes-warm/consumed,11.351246733369287 +reducible-n0500-s01729,reducible,500,1729,structure/irreducible-cold,10.924206318707414 +reducible-n0500-s01729,reducible,500,1729,structure/irreducible-warm,22.779734751658275 +reducible-n0500-s02718,reducible,500,2718,construction/public-consumed,10.049870138090663 +reducible-n0500-s02718,reducible,500,2718,evolution/k-10,3.4418447289764385 +reducible-n0500-s02718,reducible,500,2718,evolution/k-100,1.399572365785616 +reducible-n0500-s02718,reducible,500,2718,evolution/one-step,22.012348442224212 +reducible-n0500-s02718,reducible,500,2718,hitting-probability/cold-all-states,3.687348291629801 +reducible-n0500-s02718,reducible,500,2718,hitting-time/cold-all-states,5.361123953532603 +reducible-n0500-s02718,reducible,500,2718,power/10,13.591624303485647 +reducible-n0500-s02718,reducible,500,2718,power/100,9.613041372549699 +reducible-n0500-s02718,reducible,500,2718,power/2,19.86014138451214 +reducible-n0500-s02718,reducible,500,2718,stationary,18.604952392740703 +reducible-n0500-s02718,reducible,500,2718,structure/classes-cold,10.65405615416232 +reducible-n0500-s02718,reducible,500,2718,structure/classes-lifecycle,8.253883179736729 +reducible-n0500-s02718,reducible,500,2718,structure/classes-warm/access,24.64314837570111 +reducible-n0500-s02718,reducible,500,2718,structure/classes-warm/consumed,11.36480378416838 +reducible-n0500-s02718,reducible,500,2718,structure/irreducible-cold,10.846067849561598 +reducible-n0500-s02718,reducible,500,2718,structure/irreducible-warm,23.02981500438876 +reducible-n0500-s31415,reducible,500,31415,construction/public-consumed,9.848383966335494 +reducible-n0500-s31415,reducible,500,31415,evolution/k-10,3.382004316086138 +reducible-n0500-s31415,reducible,500,31415,evolution/k-100,1.3983557384905259 +reducible-n0500-s31415,reducible,500,31415,evolution/one-step,21.72474801255448 +reducible-n0500-s31415,reducible,500,31415,hitting-probability/cold-all-states,3.8822890031130726 +reducible-n0500-s31415,reducible,500,31415,hitting-time/cold-all-states,5.411729091069608 +reducible-n0500-s31415,reducible,500,31415,power/10,13.160688946702583 +reducible-n0500-s31415,reducible,500,31415,power/100,9.56340303417705 +reducible-n0500-s31415,reducible,500,31415,power/2,20.1602873641101 +reducible-n0500-s31415,reducible,500,31415,stationary,18.997318719689495 +reducible-n0500-s31415,reducible,500,31415,structure/classes-cold,10.77024432380495 +reducible-n0500-s31415,reducible,500,31415,structure/classes-lifecycle,8.163676610477374 +reducible-n0500-s31415,reducible,500,31415,structure/classes-warm/access,25.079202257982615 +reducible-n0500-s31415,reducible,500,31415,structure/classes-warm/consumed,11.374177256777504 +reducible-n0500-s31415,reducible,500,31415,structure/irreducible-cold,10.906249053038815 +reducible-n0500-s31415,reducible,500,31415,structure/irreducible-warm,23.365344803336527 +reducible-n1000-s01729,reducible,1000,1729,construction/public-consumed,8.816293277230699 +reducible-n1000-s01729,reducible,1000,1729,evolution/k-10,1.8309296745883208 +reducible-n1000-s01729,reducible,1000,1729,evolution/k-100,1.0590482114856477 +reducible-n1000-s01729,reducible,1000,1729,evolution/one-step,9.521285495368176 +reducible-n1000-s01729,reducible,1000,1729,structure/classes-cold,3.9871219599423755 +reducible-n1000-s01729,reducible,1000,1729,structure/classes-lifecycle,6.546840780218749 +reducible-n1000-s01729,reducible,1000,1729,structure/classes-warm/access,25.082683289671884 +reducible-n1000-s01729,reducible,1000,1729,structure/classes-warm/consumed,11.48570717737274 +reducible-n1000-s01729,reducible,1000,1729,structure/irreducible-cold,4.1859207246114805 +reducible-n1000-s01729,reducible,1000,1729,structure/irreducible-warm,23.288310823685872 +reducible-n1000-s02718,reducible,1000,2718,construction/public-consumed,9.029575207014528 +reducible-n1000-s02718,reducible,1000,2718,evolution/k-10,1.8672945712283702 +reducible-n1000-s02718,reducible,1000,2718,evolution/k-100,1.0638168348168835 +reducible-n1000-s02718,reducible,1000,2718,evolution/one-step,9.403272459174374 +reducible-n1000-s02718,reducible,1000,2718,structure/classes-cold,4.058687884542632 +reducible-n1000-s02718,reducible,1000,2718,structure/classes-lifecycle,6.530642877748845 +reducible-n1000-s02718,reducible,1000,2718,structure/classes-warm/access,25.10343048820243 +reducible-n1000-s02718,reducible,1000,2718,structure/classes-warm/consumed,11.641736775015442 +reducible-n1000-s02718,reducible,1000,2718,structure/irreducible-cold,4.180041596964045 +reducible-n1000-s02718,reducible,1000,2718,structure/irreducible-warm,23.600489900299664 +reducible-n1000-s31415,reducible,1000,31415,construction/public-consumed,8.925409172603155 +reducible-n1000-s31415,reducible,1000,31415,evolution/k-10,1.8135892520400727 +reducible-n1000-s31415,reducible,1000,31415,evolution/k-100,1.0497962530255964 +reducible-n1000-s31415,reducible,1000,31415,evolution/one-step,9.56546152779292 +reducible-n1000-s31415,reducible,1000,31415,structure/classes-cold,3.864407963348357 +reducible-n1000-s31415,reducible,1000,31415,structure/classes-lifecycle,6.506691942526173 +reducible-n1000-s31415,reducible,1000,31415,structure/classes-warm/access,25.273717724968368 +reducible-n1000-s31415,reducible,1000,31415,structure/classes-warm/consumed,11.627063837438694 +reducible-n1000-s31415,reducible,1000,31415,structure/irreducible-cold,4.134915523707161 +reducible-n1000-s31415,reducible,1000,31415,structure/irreducible-warm,23.60214267614018 diff --git a/benchmark/results/scaling.csv b/benchmark/results/scaling.csv new file mode 100644 --- /dev/null +++ b/benchmark/results/scaling.csv @@ -0,0 +1,355 @@ +engine,family,operation,slope,r_squared,minimum_size,maximum_size,points +dtmc,absorbing,absorption-time,1.9195238547964864,0.981033190272428,10,500,6 +dtmc,absorbing,absorption/probabilities,1.8073290016536392,0.973549002940442,10,500,6 +dtmc,absorbing,construction/public-consumed,2.1773435232191423,0.9976901847826014,10,1000,7 +dtmc,absorbing,evolution/k-10,1.5947243406759717,0.9333837247848489,10,1000,7 +dtmc,absorbing,evolution/k-100,1.9561072001244348,0.9796538039045845,10,1000,7 +dtmc,absorbing,evolution/one-step,1.4850272928248325,0.9418409440108374,10,1000,7 +dtmc,absorbing,finite-time/n-step/k-10,0.602058733802258,0.9143462004543387,10,100,4 +dtmc,absorbing,finite-time/n-step/k-100,0.7417596598201364,0.9373586723869528,10,100,4 +dtmc,absorbing,finite-time/observation/k-10,0.6262837832713137,0.9377817182886115,10,100,4 +dtmc,absorbing,finite-time/observation/k-100,0.7428894988090347,0.9396756760354099,10,100,4 +dtmc,absorbing,finite-time/step,0.060021156189919773,0.927423097233393,10,100,4 +dtmc,absorbing,fundamental-matrix,1.868191090964338,0.9907598520935696,10,500,6 +dtmc,absorbing,hitting-probability/cold-all-states,1.9127622159941922,0.972574609024916,10,500,6 +dtmc,absorbing,hitting-probability/warm-lookup,-0.0021550060507082446,0.07140918155877374,10,500,6 +dtmc,absorbing,hitting-time/cold-all-states,1.9427835864464746,0.9754301789547879,10,500,6 +dtmc,absorbing,hitting-time/warm-lookup,0.0016993934293640185,0.6555028652280378,10,500,6 +dtmc,absorbing,hitting/bounded/at-most/k-10,0.6133856069010029,0.9220370732021557,10,100,4 +dtmc,absorbing,hitting/bounded/at-most/k-100,0.7305670597231035,0.9293185455697444,10,100,4 +dtmc,absorbing,hitting/bounded/exact/k-10,0.6186216752876277,0.9218887337489746,10,100,4 +dtmc,absorbing,hitting/bounded/exact/k-100,0.7346172570299482,0.9288548839635913,10,100,4 +dtmc,absorbing,hitting/bounded/greater-than/k-10,0.628714987446123,0.9213328135877489,10,100,4 +dtmc,absorbing,hitting/bounded/greater-than/k-100,0.7329147768272993,0.9284777820312973,10,100,4 +dtmc,absorbing,occupation-matrix,2.102429186132352,0.9939243111225212,10,250,5 +dtmc,absorbing,power/10,1.8624117462251326,0.9877584323646178,10,500,6 +dtmc,absorbing,power/100,1.9220741846626435,0.9817367685469393,10,500,6 +dtmc,absorbing,power/2,1.8126936894698291,0.9930605701562928,10,500,6 +dtmc,absorbing,return/bounded/k-10,0.6072099193681824,0.9067378997578401,10,100,4 +dtmc,absorbing,return/bounded/k-100,0.7350497017349136,0.9291835422448241,10,100,4 +dtmc,absorbing,stationary,1.8589169260697518,0.9748172837782327,10,500,6 +dtmc,absorbing,structure/classes-cold,2.08582849417691,0.9783819160191076,10,1000,7 +dtmc,absorbing,structure/classes-lifecycle,2.2449554719284905,0.9972705223512971,10,1000,7 +dtmc,absorbing,structure/classes-warm/access,0.0013966508951055842,0.02879862693136015,10,1000,7 +dtmc,absorbing,structure/classes-warm/consumed,1.0332424263420532,0.9998459722881607,10,1000,7 +dtmc,absorbing,structure/irreducible-cold,2.1693401762012328,0.9833584638498742,10,1000,7 +dtmc,absorbing,structure/irreducible-warm,-0.00028885715962151956,0.03631592917276938,10,1000,7 +dtmc,absorbing,visits/bounded-expectation/k-10,0.4624326614843249,0.8965693176971989,10,100,4 +dtmc,absorbing,visits/bounded-expectation/k-100,0.5192422311094924,0.8907217072815625,10,100,4 +dtmc,dense,construction/public-consumed,2.1606761624505824,0.9980424423644378,10,1000,7 +dtmc,dense,evolution/k-10,1.5430575676138663,0.9444257686851366,10,1000,7 +dtmc,dense,evolution/k-100,1.8958560815386463,0.9845320899701421,10,1000,7 +dtmc,dense,evolution/one-step,1.4411795904368805,0.9484205719209869,10,1000,7 +dtmc,dense,finite-time/n-step/k-10,0.6042087935755416,0.9900290036233489,10,100,4 +dtmc,dense,finite-time/n-step/k-100,0.6219699457598565,0.5541671118950569,10,100,4 +dtmc,dense,finite-time/observation/k-10,0.5855075969861951,0.8391527303383902,10,100,4 +dtmc,dense,finite-time/observation/k-100,0.7288673435248294,0.9667939578014114,10,100,4 +dtmc,dense,finite-time/step,0.2773685710272736,0.8808717747868057,10,100,4 +dtmc,dense,hitting-probability/cold-all-states,1.8644071774107622,0.9774566158291859,10,500,6 +dtmc,dense,hitting-probability/warm-lookup,-0.01826853252263155,0.10502518709123654,10,500,6 +dtmc,dense,hitting-time/cold-all-states,1.8847250554843327,0.9794486279400662,10,500,6 +dtmc,dense,hitting-time/warm-lookup,-0.03277939045196968,0.32750414344619994,10,500,6 +dtmc,dense,hitting/bounded/at-most/k-10,0.658754871136132,0.9545997521225444,10,100,4 +dtmc,dense,hitting/bounded/at-most/k-100,0.7194249098887219,0.9481342610838657,10,100,4 +dtmc,dense,hitting/bounded/exact/k-10,0.6614727171259788,0.9757876644104683,10,100,4 +dtmc,dense,hitting/bounded/exact/k-100,0.7331142895509268,0.944945454011279,10,100,4 +dtmc,dense,hitting/bounded/greater-than/k-10,0.6529416778136882,0.9687538573161106,10,100,4 +dtmc,dense,hitting/bounded/greater-than/k-100,0.7375740766455908,0.9535772589830013,10,100,4 +dtmc,dense,power/10,1.8211164941574636,0.9911447740726665,10,500,6 +dtmc,dense,power/100,1.8809802327290104,0.9872327139474103,10,500,6 +dtmc,dense,power/2,1.7708297461647682,0.9943164587189565,10,500,6 +dtmc,dense,race/forward-committor,1.8743910604304912,0.9738472551727327,10,500,6 +dtmc,dense,return/bounded/k-10,0.6072884095520291,0.9800540954364297,10,100,4 +dtmc,dense,return/bounded/k-100,0.7119606290485568,0.9697283021187532,10,100,4 +dtmc,dense,return/mean-recurrence,2.303157861351915,0.9808374004506275,10,500,6 +dtmc,dense,simulation/10000,0.4396833103117382,0.6827162827626048,10,1000,7 +dtmc,dense,simulation/100000,0.10332782264703393,0.3961721277282604,10,1000,7 +dtmc,dense,stationary,2.321012566993252,0.9857104122688811,10,500,6 +dtmc,dense,structure/classes-cold,1.8920234847234747,0.9859507495982571,10,500,6 +dtmc,dense,structure/classes-lifecycle,2.1816037519646567,0.9990129575763403,10,500,6 +dtmc,dense,structure/classes-warm/access,-0.04985648103609124,0.2569303202980062,10,500,6 +dtmc,dense,structure/classes-warm/consumed,1.0113926072269692,0.9942594599838267,10,500,6 +dtmc,dense,structure/irreducible-cold,1.9760028019970102,0.987907007905674,10,500,6 +dtmc,dense,structure/irreducible-warm,-0.02444439883525026,0.15903775976327073,10,500,6 +dtmc,dense,visits/bounded-expectation/k-10,0.46670576696567445,0.9957982062064301,10,100,4 +dtmc,dense,visits/bounded-expectation/k-100,0.49334901852483565,0.9265688874883282,10,100,4 +dtmc,low-outdegree,construction/public-consumed,2.1795158533010155,0.997638161199804,10,1000,7 +dtmc,low-outdegree,evolution/k-10,1.5892698671735705,0.9339773634655418,10,1000,7 +dtmc,low-outdegree,evolution/k-100,1.949325148117891,0.980638498588136,10,1000,7 +dtmc,low-outdegree,evolution/one-step,1.4835945659521521,0.9419904652339841,10,1000,7 +dtmc,low-outdegree,finite-time/n-step/k-10,0.5999495404319366,0.919491980327024,10,100,4 +dtmc,low-outdegree,finite-time/n-step/k-100,0.7402375279517935,0.9382721272842738,10,100,4 +dtmc,low-outdegree,finite-time/observation/k-10,0.6255291241312794,0.9404510141416572,10,100,4 +dtmc,low-outdegree,finite-time/observation/k-100,0.7415297916855479,0.9400328238021467,10,100,4 +dtmc,low-outdegree,finite-time/step,0.05905982424524078,0.99620928523398,10,100,4 +dtmc,low-outdegree,hitting-probability/cold-all-states,1.659316374477676,0.970335028555907,10,500,6 +dtmc,low-outdegree,hitting-probability/warm-lookup,-0.0034539492514896594,0.39455748744988894,10,500,6 +dtmc,low-outdegree,hitting-time/cold-all-states,1.6853022716903965,0.9718269496391623,10,500,6 +dtmc,low-outdegree,hitting-time/warm-lookup,-0.0005507037395714477,0.016101918117363723,10,500,6 +dtmc,low-outdegree,hitting/bounded/at-most/k-10,0.6615201042858287,0.907232737013514,10,100,4 +dtmc,low-outdegree,hitting/bounded/at-most/k-100,0.7418575764427846,0.9256857622198064,10,100,4 +dtmc,low-outdegree,hitting/bounded/exact/k-10,0.6630576419305351,0.9079172075111125,10,100,4 +dtmc,low-outdegree,hitting/bounded/exact/k-100,0.7431745458400211,0.9285802999135863,10,100,4 +dtmc,low-outdegree,hitting/bounded/greater-than/k-10,0.6716593278184159,0.9094176577609011,10,100,4 +dtmc,low-outdegree,hitting/bounded/greater-than/k-100,0.7367461461779325,0.9298149811441052,10,100,4 +dtmc,low-outdegree,power/10,1.8587944799582121,0.988189045431658,10,500,6 +dtmc,low-outdegree,power/100,1.9195151890401596,0.9817108473780727,10,500,6 +dtmc,low-outdegree,power/2,1.8077637703168055,0.9930366783746781,10,500,6 +dtmc,low-outdegree,race/forward-committor,1.65299225535345,0.9695365316476539,10,500,6 +dtmc,low-outdegree,return/bounded/k-10,0.6046458465790945,0.9143690012093741,10,100,4 +dtmc,low-outdegree,return/bounded/k-100,0.7345356985274937,0.9333518201320619,10,100,4 +dtmc,low-outdegree,return/mean-recurrence,2.3435005948643544,0.970558575790408,10,500,6 +dtmc,low-outdegree,simulation/10000,0.08742995847763217,0.5806665298305935,10,1000,7 +dtmc,low-outdegree,simulation/100000,0.010911676565053562,0.4341651347634059,10,1000,7 +dtmc,low-outdegree,stationary,2.3633130822873287,0.9717801170005494,10,500,6 +dtmc,low-outdegree,structure/classes-cold,1.033006499471462,0.9926126010281888,10,1000,7 +dtmc,low-outdegree,structure/classes-lifecycle,2.124481625848366,0.9960916805828021,10,1000,7 +dtmc,low-outdegree,structure/classes-warm/access,-0.00011060461612300633,0.0016300773971561489,10,1000,7 +dtmc,low-outdegree,structure/classes-warm/consumed,1.0491528677424942,0.9997061233920702,10,1000,7 +dtmc,low-outdegree,structure/irreducible-cold,0.9567053764210885,0.9815749666159457,10,1000,7 +dtmc,low-outdegree,structure/irreducible-warm,0.0020520415849182207,0.46990858253423573,10,1000,7 +dtmc,low-outdegree,visits/bounded-expectation/k-10,0.4581997206489291,0.8984615729886065,10,100,4 +dtmc,low-outdegree,visits/bounded-expectation/k-100,0.5193788357721885,0.8926829484491126,10,100,4 +dtmc,periodic,construction/public-consumed,2.1806548054069803,0.9975634036431378,10,1000,7 +dtmc,periodic,evolution/k-10,1.5724888768484964,0.9374183361943965,10,1000,7 +dtmc,periodic,evolution/k-100,1.9341172403340867,0.9818729731997282,10,1000,7 +dtmc,periodic,evolution/one-step,1.4668666287187722,0.9457600488486243,10,1000,7 +dtmc,periodic,finite-time/n-step/k-10,0.4410200527688925,0.9817437212759746,10,100,4 +dtmc,periodic,finite-time/n-step/k-100,0.5500849218739652,0.9891832007373117,10,100,4 +dtmc,periodic,finite-time/observation/k-10,1.5386479333045044,0.9986254972808293,10,100,4 +dtmc,periodic,finite-time/observation/k-100,1.542125783999743,0.9997777855515952,10,100,4 +dtmc,periodic,finite-time/step,0.052122967411920705,0.9575864978855594,10,100,4 +dtmc,periodic,hitting-probability/cold-all-states,1.6726903311496157,0.9692354655764254,10,500,6 +dtmc,periodic,hitting-probability/warm-lookup,0.0010172874979772716,0.20386627013485226,10,500,6 +dtmc,periodic,hitting-time/cold-all-states,1.7012718346172864,0.9713685785019636,10,500,6 +dtmc,periodic,hitting-time/warm-lookup,-0.0022858864140168343,0.4248860336861967,10,500,6 +dtmc,periodic,hitting/bounded/at-most/k-10,0.562280449948348,0.9851792407628499,10,100,4 +dtmc,periodic,hitting/bounded/at-most/k-100,1.1826450885173614,0.9802462876404304,10,100,4 +dtmc,periodic,hitting/bounded/exact/k-10,0.5776139164932865,0.9860165065531393,10,100,4 +dtmc,periodic,hitting/bounded/exact/k-100,1.2006706613374811,0.9820393035320453,10,100,4 +dtmc,periodic,hitting/bounded/greater-than/k-10,0.5779039019560801,0.9846759870160031,10,100,4 +dtmc,periodic,hitting/bounded/greater-than/k-100,1.199820914989098,0.9813947493009889,10,100,4 +dtmc,periodic,power/10,1.8624423931322294,0.9876410703743865,10,500,6 +dtmc,periodic,power/100,1.9242125076662797,0.9819922861993443,10,500,6 +dtmc,periodic,power/2,1.8124011678586427,0.9930678902941427,10,500,6 +dtmc,periodic,return/bounded/k-10,0.41945170720546177,0.9788762446975698,10,100,4 +dtmc,periodic,return/bounded/k-100,1.322306032180547,0.9912868002092998,10,100,4 +dtmc,periodic,stationary,2.395501065536769,0.9727472538084918,10,500,6 +dtmc,periodic,structure/classes-cold,0.9000160673682194,0.991170433096003,10,1000,7 +dtmc,periodic,structure/classes-lifecycle,2.1458513537884896,0.9964316588137293,10,1000,7 +dtmc,periodic,structure/classes-warm/access,0.0024008716098923295,0.186991641894086,10,1000,7 +dtmc,periodic,structure/classes-warm/consumed,1.0509340682465114,0.9996686586337206,10,1000,7 +dtmc,periodic,structure/cyclic-classes-cold,1.0268296067258496,0.9923386745524607,10,1000,7 +dtmc,periodic,structure/cyclic-classes-warm,0.9936901028875729,0.9999227867927126,10,1000,7 +dtmc,periodic,structure/irreducible-cold,0.8551581423667257,0.9776883818650877,10,1000,7 +dtmc,periodic,structure/irreducible-warm,0.0044179058433547755,0.7689345965031251,10,1000,7 +dtmc,periodic,structure/period-cold,1.0223426302511918,0.9861461614620307,10,1000,7 +dtmc,periodic,structure/period-warm,-8.427906597296289e-05,0.0005186700146028178,10,1000,7 +dtmc,periodic,visits/bounded-expectation/k-10,0.44329650855895486,0.9815784475150583,10,100,4 +dtmc,periodic,visits/bounded-expectation/k-100,0.579264400684823,0.9940426880312937,10,100,4 +dtmc,reducible,construction/public-consumed,2.1794223999504787,0.9976555619633146,10,1000,7 +dtmc,reducible,evolution/k-10,1.573065858600098,0.9372462261761848,10,1000,7 +dtmc,reducible,evolution/k-100,1.934786500480062,0.9820648912740864,10,1000,7 +dtmc,reducible,evolution/one-step,1.4673472917326333,0.9463006426604729,10,1000,7 +dtmc,reducible,finite-time/n-step/k-10,0.6075584709291482,0.915092080502977,10,100,4 +dtmc,reducible,finite-time/n-step/k-100,0.7418863323221971,0.9373152587464958,10,100,4 +dtmc,reducible,finite-time/observation/k-10,0.6281038516682549,0.9400646760923952,10,100,4 +dtmc,reducible,finite-time/observation/k-100,0.7434452027055057,0.938486198451825,10,100,4 +dtmc,reducible,finite-time/step,0.1625359020479764,0.7255106935116962,10,100,4 +dtmc,reducible,hitting-probability/cold-all-states,1.7523949895227457,0.9742961071543509,10,500,6 +dtmc,reducible,hitting-probability/warm-lookup,-0.0030043016158035453,0.43783446688705485,10,500,6 +dtmc,reducible,hitting-time/cold-all-states,1.847240397584961,0.9798143554560484,10,500,6 +dtmc,reducible,hitting-time/warm-lookup,0.0007333849046841727,0.36340303779849426,10,500,6 +dtmc,reducible,hitting/bounded/at-most/k-10,0.739989548491024,0.900914336847091,10,100,4 +dtmc,reducible,hitting/bounded/at-most/k-100,0.7541819276014042,0.9207638277515047,10,100,4 +dtmc,reducible,hitting/bounded/exact/k-10,0.7430083461868351,0.9044747355742562,10,100,4 +dtmc,reducible,hitting/bounded/exact/k-100,0.7553511293916818,0.925457303616843,10,100,4 +dtmc,reducible,hitting/bounded/greater-than/k-10,0.7747137560139209,0.9009723786868011,10,100,4 +dtmc,reducible,hitting/bounded/greater-than/k-100,0.7512852010999017,0.9261852483493564,10,100,4 +dtmc,reducible,occupation-matrix,2.0187219159422267,0.9978037458307174,10,250,5 +dtmc,reducible,power/10,1.8648401012769555,0.9876720999104576,10,500,6 +dtmc,reducible,power/100,1.9244820378732077,0.9817955786293057,10,500,6 +dtmc,reducible,power/2,1.8133324947344938,0.9929690387833927,10,500,6 +dtmc,reducible,return/bounded/k-10,0.6163263384646573,0.9026281287559427,10,100,4 +dtmc,reducible,return/bounded/k-100,0.736002522932519,0.9289618315200274,10,100,4 +dtmc,reducible,stationary,1.620971573581422,0.9733881341029521,10,500,6 +dtmc,reducible,structure/classes-cold,1.9324362272310442,0.9737925902768828,10,1000,7 +dtmc,reducible,structure/classes-lifecycle,2.203589696356461,0.997178384274759,10,1000,7 +dtmc,reducible,structure/classes-warm/access,0.00036057104354168205,0.004037154342862781,10,1000,7 +dtmc,reducible,structure/classes-warm/consumed,1.0335692360927002,0.9999095330621985,10,1000,7 +dtmc,reducible,structure/irreducible-cold,2.012041192960249,0.9802155292130662,10,1000,7 +dtmc,reducible,structure/irreducible-warm,0.002259778336229745,0.12439925455255407,10,1000,7 +dtmc,reducible,visits/bounded-expectation/k-10,0.4573352776182256,0.9104964381052172,10,100,4 +dtmc,reducible,visits/bounded-expectation/k-100,0.5193501239188153,0.8908897778027056,10,100,4 +pydtmc,absorbing,absorption-time,1.6563133382460724,0.9906235088876675,10,500,6 +pydtmc,absorbing,absorption/probabilities,1.6527782722441893,0.990682354282097,10,500,6 +pydtmc,absorbing,construction/public-consumed,1.8289153921881596,0.9916739666090286,10,1000,7 +pydtmc,absorbing,evolution/k-10,0.9236648501030605,0.9193629347808141,10,1000,7 +pydtmc,absorbing,evolution/k-100,0.9229294510210294,0.8426269362034389,10,1000,7 +pydtmc,absorbing,evolution/one-step,0.9225999735314129,0.9597468044634786,10,1000,7 +pydtmc,absorbing,finite-time/n-step/k-10,0.4369009246982506,0.9525990789861781,10,100,4 +pydtmc,absorbing,finite-time/n-step/k-100,0.22426221455784617,0.851757866470338,10,100,4 +pydtmc,absorbing,finite-time/observation/k-10,0.43778348418972657,0.949216009439381,10,100,4 +pydtmc,absorbing,finite-time/observation/k-100,0.22837946200895573,0.8678558399201526,10,100,4 +pydtmc,absorbing,finite-time/step,0.5245614270276148,0.9457550606467161,10,100,4 +pydtmc,absorbing,fundamental-matrix,1.6639108633986472,0.9917810238251675,10,500,6 +pydtmc,absorbing,hitting-probability/cold-all-states,2.0158887659578806,0.9386371550835175,10,500,6 +pydtmc,absorbing,hitting-time/cold-all-states,2.0036245184405086,0.9371017805293589,10,500,6 +pydtmc,absorbing,hitting/bounded/at-most/k-10,0.586627872616529,0.9382141612215857,10,100,4 +pydtmc,absorbing,hitting/bounded/at-most/k-100,0.6785635447562972,0.9438106107583565,10,100,4 +pydtmc,absorbing,hitting/bounded/exact/k-10,0.5990096938137547,0.9395857165831389,10,100,4 +pydtmc,absorbing,hitting/bounded/exact/k-100,0.6795648560308365,0.9463633640921499,10,100,4 +pydtmc,absorbing,hitting/bounded/greater-than/k-10,0.5818156290717283,0.9418604344103609,10,100,4 +pydtmc,absorbing,hitting/bounded/greater-than/k-100,0.679273722666409,0.9436702913968544,10,100,4 +pydtmc,absorbing,occupation-matrix,1.9907444243760277,0.9994060555063607,10,250,5 +pydtmc,absorbing,power/10,1.5795546096077657,0.9658927437215119,10,500,6 +pydtmc,absorbing,power/100,1.584191144010973,0.9658905892988038,10,500,6 +pydtmc,absorbing,power/2,1.5752581713718092,0.9666375328232776,10,500,6 +pydtmc,absorbing,return/bounded/k-10,0.59400679309191,0.9369572057816027,10,100,4 +pydtmc,absorbing,return/bounded/k-100,0.6854796599056292,0.9461140322872452,10,100,4 +pydtmc,absorbing,stationary,1.7797525616083583,0.9931220290108471,10,500,6 +pydtmc,absorbing,structure/classes-cold,1.899142447842065,0.9981173590230864,10,1000,7 +pydtmc,absorbing,structure/classes-lifecycle,1.8246786579625842,0.9915371436901769,10,1000,7 +pydtmc,absorbing,structure/classes-warm/access,-0.001900713546690201,0.6461337088173997,10,1000,7 +pydtmc,absorbing,structure/classes-warm/consumed,0.9018906814963071,0.9924230628889095,10,1000,7 +pydtmc,absorbing,structure/irreducible-cold,1.8977488916586591,0.9982347511045794,10,1000,7 +pydtmc,absorbing,structure/irreducible-warm,-0.0028561531578189556,0.3492349125876889,10,1000,7 +pydtmc,absorbing,visits/bounded-expectation/k-10,0.687905879415785,0.9833848785408758,10,100,4 +pydtmc,absorbing,visits/bounded-expectation/k-100,0.45301452781255386,0.9180321652993821,10,100,4 +pydtmc,dense,construction/public-consumed,1.7877214496247114,0.9928104933716604,10,1000,7 +pydtmc,dense,evolution/k-10,0.8959411978878998,0.9177461650400064,10,1000,7 +pydtmc,dense,evolution/k-100,0.8890153949118346,0.8323874877597557,10,1000,7 +pydtmc,dense,evolution/one-step,0.8832328859042947,0.9582798897949258,10,1000,7 +pydtmc,dense,finite-time/n-step/k-10,0.3928347941683356,0.9967284581214325,10,100,4 +pydtmc,dense,finite-time/n-step/k-100,0.19659725908077985,0.9021382085498973,10,100,4 +pydtmc,dense,finite-time/observation/k-10,0.4589156973176959,0.931009718466162,10,100,4 +pydtmc,dense,finite-time/observation/k-100,0.20232516479239968,0.9431984235677932,10,100,4 +pydtmc,dense,finite-time/step,0.5179823124820514,0.6446609500675884,10,100,4 +pydtmc,dense,hitting-probability/cold-all-states,1.9053140504614101,0.9437022099418906,10,500,6 +pydtmc,dense,hitting-time/cold-all-states,1.9122665964274044,0.9396112702375056,10,500,6 +pydtmc,dense,hitting/bounded/at-most/k-10,0.5799683981437544,0.9991753225828635,10,100,4 +pydtmc,dense,hitting/bounded/at-most/k-100,0.6861394078811283,0.983642185410522,10,100,4 +pydtmc,dense,hitting/bounded/exact/k-10,0.5892263137840307,0.9935152825272336,10,100,4 +pydtmc,dense,hitting/bounded/exact/k-100,0.6709509362260114,0.9715586960951186,10,100,4 +pydtmc,dense,hitting/bounded/greater-than/k-10,0.5992319878740899,0.9977335208747117,10,100,4 +pydtmc,dense,hitting/bounded/greater-than/k-100,0.6845084909891309,0.9842714403810258,10,100,4 +pydtmc,dense,power/10,1.5291343415633396,0.9731430596482928,10,500,6 +pydtmc,dense,power/100,1.5409975578771287,0.96957260496637,10,500,6 +pydtmc,dense,power/2,1.527375076241621,0.9740562296736484,10,500,6 +pydtmc,dense,race/forward-committor,1.7380311989067045,0.9940465720838502,10,500,6 +pydtmc,dense,return/bounded/k-10,0.555636389094659,0.9921263431045758,10,100,4 +pydtmc,dense,return/bounded/k-100,0.6899462492600192,0.9839887024851537,10,100,4 +pydtmc,dense,return/mean-recurrence,1.6993318719839774,0.994104310368393,10,500,6 +pydtmc,dense,simulation/10000,0.10897952907869943,0.6321954109001818,10,1000,7 +pydtmc,dense,simulation/100000,0.11870515817032982,0.7253812498903008,10,1000,7 +pydtmc,dense,stationary,1.7232647891978747,0.9864724976577884,10,500,6 +pydtmc,dense,structure/classes-cold,1.805665668969697,0.9974030275247077,10,500,6 +pydtmc,dense,structure/classes-lifecycle,1.721118006086256,0.99356834235198,10,500,6 +pydtmc,dense,structure/classes-warm/access,-0.026712100503040077,0.4337389756334079,10,500,6 +pydtmc,dense,structure/classes-warm/consumed,0.8340013300431085,0.9869788652815747,10,500,6 +pydtmc,dense,structure/irreducible-cold,1.786547996651112,0.9974478525488361,10,500,6 +pydtmc,dense,structure/irreducible-warm,-0.041418219365208536,0.31218510871222194,10,500,6 +pydtmc,dense,visits/bounded-expectation/k-10,0.6375558188032469,0.9985299093912111,10,100,4 +pydtmc,dense,visits/bounded-expectation/k-100,0.4705441789336271,0.9918541184071888,10,100,4 +pydtmc,low-outdegree,construction/public-consumed,1.7571656452548896,0.9879336835695021,10,1000,7 +pydtmc,low-outdegree,evolution/k-10,0.9303342395701916,0.896522519488752,10,1000,7 +pydtmc,low-outdegree,evolution/k-100,0.9220170407384933,0.8334758501436165,10,1000,7 +pydtmc,low-outdegree,evolution/one-step,0.9000181578853286,0.9450400598635339,10,1000,7 +pydtmc,low-outdegree,finite-time/n-step/k-10,0.42711660722914346,0.9562389400168788,10,100,4 +pydtmc,low-outdegree,finite-time/n-step/k-100,0.21443224437118644,0.8621363795738705,10,100,4 +pydtmc,low-outdegree,finite-time/observation/k-10,0.4255548569351263,0.9567561745481891,10,100,4 +pydtmc,low-outdegree,finite-time/observation/k-100,0.2176710998150925,0.8637561615018766,10,100,4 +pydtmc,low-outdegree,finite-time/step,0.4800026815565106,0.9313127088262815,10,100,4 +pydtmc,low-outdegree,hitting-probability/cold-all-states,1.9652447280437093,0.9408404975412246,10,500,6 +pydtmc,low-outdegree,hitting-time/cold-all-states,1.946792917649129,0.9385216344559736,10,500,6 +pydtmc,low-outdegree,hitting/bounded/at-most/k-10,0.5982876758708825,0.9365840644538641,10,100,4 +pydtmc,low-outdegree,hitting/bounded/at-most/k-100,0.6921421410552896,0.9563407163180782,10,100,4 +pydtmc,low-outdegree,hitting/bounded/exact/k-10,0.5975718333688115,0.9424596694519219,10,100,4 +pydtmc,low-outdegree,hitting/bounded/exact/k-100,0.6952483467670335,0.9535095150005012,10,100,4 +pydtmc,low-outdegree,hitting/bounded/greater-than/k-10,0.5941924427797727,0.9398870367102958,10,100,4 +pydtmc,low-outdegree,hitting/bounded/greater-than/k-100,0.6856262072426459,0.9483152306624912,10,100,4 +pydtmc,low-outdegree,power/10,1.5698951360115008,0.966540625423871,10,500,6 +pydtmc,low-outdegree,power/100,1.5738149542734563,0.9666467513909445,10,500,6 +pydtmc,low-outdegree,power/2,1.125777492879955,0.935995284606175,10,500,6 +pydtmc,low-outdegree,race/forward-committor,1.598415958717786,0.980390654915706,10,500,6 +pydtmc,low-outdegree,return/bounded/k-10,0.5901053961086412,0.9399163589163224,10,100,4 +pydtmc,low-outdegree,return/bounded/k-100,0.6822276939530655,0.9524322240081469,10,100,4 +pydtmc,low-outdegree,return/mean-recurrence,1.5715522661090133,0.9831056591613132,10,500,6 +pydtmc,low-outdegree,simulation/10000,0.14442110041793907,0.8038479266375054,10,1000,7 +pydtmc,low-outdegree,simulation/100000,0.1442519911675602,0.8080484449818863,10,1000,7 +pydtmc,low-outdegree,stationary,1.6241741398408904,0.9639217783151773,10,500,6 +pydtmc,low-outdegree,structure/classes-cold,1.2040970160381614,0.987353405218041,10,1000,7 +pydtmc,low-outdegree,structure/classes-lifecycle,1.7264632098627923,0.9857854509314946,10,1000,7 +pydtmc,low-outdegree,structure/classes-warm/access,0.0014478005651109072,0.27655397937915094,10,1000,7 +pydtmc,low-outdegree,structure/classes-warm/consumed,0.9083293085165135,0.9937384759983767,10,1000,7 +pydtmc,low-outdegree,structure/irreducible-cold,1.2060691228574836,0.9867351970085785,10,1000,7 +pydtmc,low-outdegree,structure/irreducible-warm,-0.000481153946225512,0.05134687776934066,10,1000,7 +pydtmc,low-outdegree,visits/bounded-expectation/k-10,0.6807906408678776,0.9857103005002874,10,100,4 +pydtmc,low-outdegree,visits/bounded-expectation/k-100,0.44416955540038666,0.9182160228575306,10,100,4 +pydtmc,periodic,construction/public-consumed,1.7618288240571645,0.9880848426210534,10,1000,7 +pydtmc,periodic,evolution/k-10,0.930504749048623,0.8996588701819137,10,1000,7 +pydtmc,periodic,evolution/k-100,0.9260415209003517,0.8318584551011015,10,1000,7 +pydtmc,periodic,evolution/one-step,0.9269420598897855,0.942355101054317,10,1000,7 +pydtmc,periodic,finite-time/n-step/k-10,0.42717727411461864,0.9623024287091488,10,100,4 +pydtmc,periodic,finite-time/n-step/k-100,0.2172486246854124,0.873986311463337,10,100,4 +pydtmc,periodic,finite-time/observation/k-10,0.4260445435696743,0.9584465951045648,10,100,4 +pydtmc,periodic,finite-time/observation/k-100,0.21395493509963467,0.8613477079967133,10,100,4 +pydtmc,periodic,finite-time/step,0.4425123779989751,0.9220352179872526,10,100,4 +pydtmc,periodic,hitting-probability/cold-all-states,1.864231257057766,0.9360119313418244,10,500,6 +pydtmc,periodic,hitting-time/cold-all-states,1.8738462059342844,0.9359771160829395,10,500,6 +pydtmc,periodic,hitting/bounded/at-most/k-10,0.5939124315433606,0.9392934581676895,10,100,4 +pydtmc,periodic,hitting/bounded/at-most/k-100,0.6920116826900425,0.9542108485249848,10,100,4 +pydtmc,periodic,hitting/bounded/exact/k-10,0.6040935382747225,0.9440930560700309,10,100,4 +pydtmc,periodic,hitting/bounded/exact/k-100,0.6876909277164276,0.9572310218673054,10,100,4 +pydtmc,periodic,hitting/bounded/greater-than/k-10,0.5892451959149275,0.9399737827428081,10,100,4 +pydtmc,periodic,hitting/bounded/greater-than/k-100,0.6842892674738814,0.9575943453679232,10,100,4 +pydtmc,periodic,power/10,1.1482343081629525,0.8952264137641773,10,500,6 +pydtmc,periodic,power/100,1.179167803860144,0.8946476673170538,10,500,6 +pydtmc,periodic,power/2,1.1266488787178655,0.8968972807373006,10,500,6 +pydtmc,periodic,return/bounded/k-10,0.5857144928531878,0.938729568211715,10,100,4 +pydtmc,periodic,return/bounded/k-100,0.6885706161811557,0.9523052595953188,10,100,4 +pydtmc,periodic,stationary,1.644438615107619,0.9642996705751069,10,500,6 +pydtmc,periodic,structure/classes-cold,1.2328239712638143,0.9812155691246459,10,1000,7 +pydtmc,periodic,structure/classes-lifecycle,1.7338717108155797,0.9862443685661271,10,1000,7 +pydtmc,periodic,structure/classes-warm/access,-0.0022377295649723497,0.07887940811707417,10,1000,7 +pydtmc,periodic,structure/classes-warm/consumed,0.9131774566133594,0.9935982007150801,10,1000,7 +pydtmc,periodic,structure/cyclic-classes-cold,1.6101943162443333,0.9903298094958808,10,1000,7 +pydtmc,periodic,structure/cyclic-classes-warm,0.9391580143864073,0.9968110086089731,10,1000,7 +pydtmc,periodic,structure/irreducible-cold,1.2409076083962303,0.9812590346259844,10,1000,7 +pydtmc,periodic,structure/irreducible-warm,0.001921252378651767,0.3260048281660608,10,1000,7 +pydtmc,periodic,structure/period-cold,1.693434505080166,0.9919838089761017,10,1000,7 +pydtmc,periodic,structure/period-warm,0.002563991656437354,0.3369777279161269,10,1000,7 +pydtmc,periodic,visits/bounded-expectation/k-10,0.7029026244832681,0.9786237164969208,10,100,4 +pydtmc,periodic,visits/bounded-expectation/k-100,0.4439232968542725,0.9097755472459956,10,100,4 +pydtmc,reducible,construction/public-consumed,1.8054999326197372,0.9909224580528485,10,1000,7 +pydtmc,reducible,evolution/k-10,0.9155321351501972,0.9162054806675198,10,1000,7 +pydtmc,reducible,evolution/k-100,0.9219380825674939,0.839768291557486,10,1000,7 +pydtmc,reducible,evolution/one-step,0.9157091997364012,0.9556306510952751,10,1000,7 +pydtmc,reducible,finite-time/n-step/k-10,0.4338211102699326,0.9523432036765039,10,100,4 +pydtmc,reducible,finite-time/n-step/k-100,0.22003022814693873,0.840448799920687,10,100,4 +pydtmc,reducible,finite-time/observation/k-10,0.49813984862407995,0.9183558920136836,10,100,4 +pydtmc,reducible,finite-time/observation/k-100,0.22520595829590256,0.8763787040671052,10,100,4 +pydtmc,reducible,finite-time/step,0.524224277644407,0.9334410249341091,10,100,4 +pydtmc,reducible,hitting-probability/cold-all-states,1.8778326683148185,0.9328668965274505,10,500,6 +pydtmc,reducible,hitting-time/cold-all-states,1.607762477267404,0.8931275892935471,10,500,6 +pydtmc,reducible,hitting/bounded/at-most/k-10,0.6000670690633979,0.9359279470896196,10,100,4 +pydtmc,reducible,hitting/bounded/at-most/k-100,0.6846936941112419,0.9540885489822202,10,100,4 +pydtmc,reducible,hitting/bounded/exact/k-10,0.6082496008762971,0.9384140696042766,10,100,4 +pydtmc,reducible,hitting/bounded/exact/k-100,0.6865657304861482,0.952900068464848,10,100,4 +pydtmc,reducible,hitting/bounded/greater-than/k-10,0.6039916697972822,0.9351262579064408,10,100,4 +pydtmc,reducible,hitting/bounded/greater-than/k-100,0.6872716613819883,0.9524810147001355,10,100,4 +pydtmc,reducible,occupation-matrix,2.077460201842771,0.9984543978058712,10,250,5 +pydtmc,reducible,power/10,1.5022858652423439,0.96656065632515,10,500,6 +pydtmc,reducible,power/100,1.5415256653516514,0.9630098520555176,10,500,6 +pydtmc,reducible,power/2,1.4822154188844927,0.9608325294011668,10,500,6 +pydtmc,reducible,return/bounded/k-10,0.5933016851726637,0.9345045964558951,10,100,4 +pydtmc,reducible,return/bounded/k-100,0.6840595990980071,0.9541692991320121,10,100,4 +pydtmc,reducible,stationary,1.670065739407094,0.9908875397949434,10,500,6 +pydtmc,reducible,structure/classes-cold,1.8224800917600859,0.997409246679184,10,1000,7 +pydtmc,reducible,structure/classes-lifecycle,1.7936281701230181,0.990672358977037,10,1000,7 +pydtmc,reducible,structure/classes-warm/access,-0.0010496298833066941,0.32991666310601375,10,1000,7 +pydtmc,reducible,structure/classes-warm/consumed,0.8989619946453712,0.9921906100437299,10,1000,7 +pydtmc,reducible,structure/irreducible-cold,1.831849199966462,0.9978765173622415,10,1000,7 +pydtmc,reducible,structure/irreducible-warm,-0.0036338683523741764,0.3307573232427624,10,1000,7 +pydtmc,reducible,visits/bounded-expectation/k-10,0.6925437812636434,0.9829434215118902,10,100,4 +pydtmc,reducible,visits/bounded-expectation/k-100,0.45509626130970454,0.9225122482832689,10,100,4 diff --git a/benchmark/results/summary.csv b/benchmark/results/summary.csv new file mode 100644 --- /dev/null +++ b/benchmark/results/summary.csv @@ -0,0 +1,5773 @@ +engine,dataset,family,size,seed,operation,median_seconds,mad_seconds,q1_seconds,q3_seconds,median_ci95_low_seconds,median_ci95_high_seconds,samples +dtmc,absorbing-n0010-s01729,absorbing,10,1729,absorption-time,1.7661520675518454e-05,9.096439556468232e-08,1.7585514512892505e-05,1.7850350559456274e-05,1.7628485067122934e-05,1.7689065822898736e-05,135 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,absorption/probabilities,1.8658519100147083e-05,7.747921000163252e-08,1.8599292353940755e-05,1.8822996177429253e-05,1.863423931170811e-05,1.8702090725153425e-05,135 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,construction/public-consumed,6.3547906946674315e-06,7.624741227842973e-09,6.349318955864262e-06,6.377820303290112e-06,6.3531630409675015e-06,6.3578890742825555e-06,173 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,evolution/k-10,1.6431732135240768e-06,2.6566498901684897e-09,1.6409956010219918e-06,1.6533913499122297e-06,1.6425185621524303e-06,1.643680332529751e-06,201 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,evolution/k-100,3.0525178046365315e-06,6.038770152190914e-09,3.047405565523679e-06,3.0590126716469627e-06,3.0513295020018927e-06,3.05367946957907e-06,188 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,evolution/one-step,2.4436622306927885e-07,9.328488216430721e-09,2.3497285359017552e-07,2.524408936637291e-07,2.437138764044305e-07,2.4497518459455584e-07,240 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,finite-time/n-step/k-10,2.9332986680904294e-06,7.153363971669006e-09,2.9269891472523076e-06,2.9430010483722795e-06,2.9316362524263005e-06,2.9354731031171375e-06,164 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,finite-time/n-step/k-100,1.745104913348172e-05,2.655960729511856e-08,1.7426646874213072e-05,1.7486028031893994e-05,1.7443445684637937e-05,1.7458054589818696e-05,140 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,finite-time/observation/k-10,3.3794605002203216e-06,1.7469898789226453e-08,3.3656463999868695e-06,3.4063219159529763e-06,3.3738578960951122e-06,3.3830848968302068e-06,160 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,finite-time/observation/k-100,1.7890995394231544e-05,2.7489911198931284e-08,1.7865115167527715e-05,1.792073062121509e-05,1.7885791090266288e-05,1.789574889698997e-05,139 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,finite-time/step,7.567962532772019e-07,6.000997178286186e-09,7.509286591031976e-07,7.646366797690531e-07,7.544219885039743e-07,7.579519664254613e-07,192 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,fundamental-matrix,2.1253302732608124e-05,1.0798688221566827e-07,2.115142826739268e-05,2.1363142755532153e-05,2.1233243030543815e-05,2.127706781417752e-05,133 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,hitting-probability/cold-all-states,1.6469227000963668e-05,7.906893247140705e-08,1.639821599383271e-05,1.6590093731284343e-05,1.643334944235969e-05,1.6495080199092627e-05,136 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,hitting-probability/warm-lookup,2.3862970123964503e-08,2.4654680296719607e-10,2.3634296636875474e-08,2.750934503732261e-08,2.3721719633820982e-08,2.417664026110053e-08,288 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,hitting-time/cold-all-states,1.4604397727707302e-05,6.023472597352243e-08,1.4552583836420145e-05,1.4694444770510825e-05,1.457929987081436e-05,1.4627066699146222e-05,137 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,hitting-time/warm-lookup,2.4167711651977286e-08,2.8788809552703546e-10,2.3900056555988082e-08,2.7657561732654658e-08,2.4009014358289525e-08,2.4462635121435128e-08,288 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,hitting/bounded/at-most/k-10,3.3437447268168914e-06,1.347674314582644e-08,3.3321425386842326e-06,3.3590470030460327e-06,3.3394615110453398e-06,3.3464821171946824e-06,161 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,hitting/bounded/at-most/k-100,1.9046138074302758e-05,2.764547743097721e-08,1.90287868809441e-05,1.9491147707282966e-05,1.9040078488894953e-05,1.905759400164897e-05,139 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,hitting/bounded/exact/k-10,3.3042148397333368e-06,2.3095513787557223e-08,3.2722030611765362e-06,3.3209979201636206e-06,3.3009913380216548e-06,3.3074325371768017e-06,162 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,hitting/bounded/exact/k-100,1.8766763818999918e-05,1.8098549193073127e-08,1.875070139617547e-05,1.8788209444359273e-05,1.8762000503816773e-05,1.877248082325279e-05,139 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,hitting/bounded/greater-than/k-10,3.2506293787284923e-06,9.624194812134736e-09,3.2445462282860003e-06,3.2663415677031027e-06,3.2490727094581084e-06,3.2538299850876445e-06,162 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,hitting/bounded/greater-than/k-100,1.8949287502449732e-05,2.324521875873354e-08,1.892215816420203e-05,1.8969031800438097e-05,1.8941034850454513e-05,1.8953295369718182e-05,139 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,occupation-matrix,4.1269719715050436e-05,9.197716317032857e-08,4.1207293067324274e-05,4.138695361756685e-05,4.1246450737792106e-05,4.130470469218298e-05,125 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,power/10,4.3806620652037785e-06,1.2326100908127838e-08,4.3693222426515435e-06,4.427783278515563e-06,4.37877450053117e-06,4.383436633829525e-06,181 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,power/100,5.664653988713258e-06,6.207510632425683e-09,5.659517097869651e-06,5.671805384620422e-06,5.663378281576876e-06,5.666445776860864e-06,176 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,power/2,3.319523615875594e-06,5.69770244740633e-09,3.3153451237832642e-06,3.3360668200801798e-06,3.31832050635061e-06,3.3213428520996656e-06,187 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,return/bounded/k-10,3.0123604389292926e-06,1.3147432167953541e-08,2.999790901621503e-06,3.0287553231045505e-06,3.0062535404625926e-06,3.0163458822005728e-06,163 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,return/bounded/k-100,1.8900495471876708e-05,4.6778460367825585e-07,1.845601573677055e-05,1.9504369712199415e-05,1.8509434732703848e-05,1.920168177180347e-05,139 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,stationary,5.537268679975964e-06,2.0466163644253923e-08,5.518739466056155e-06,5.571458844400785e-06,5.5312978751024985e-06,5.54239742332212e-06,150 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,structure/classes-cold,3.4870020580590978e-06,1.5079198279776255e-08,3.473054674460663e-06,3.502380498806209e-06,3.483497654501087e-06,3.4904984535056758e-06,160 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,structure/classes-lifecycle,8.66591566240875e-06,1.5921610967905783e-08,8.657070508734561e-06,8.803360966235642e-06,8.662863822653377e-06,8.675898726675985e-06,167 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,structure/classes-warm/access,8.642540529154966e-09,1.557352776105401e-10,8.498305026273262e-09,1.1135058627388943e-08,8.56338110749864e-09,8.768082888837483e-09,309 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,structure/classes-warm/consumed,4.399048449326219e-08,2.7728620363541744e-10,4.3777295396004824e-08,4.718731467304757e-08,4.3926518238192645e-08,4.4100436963563926e-08,275 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,structure/irreducible-cold,2.3955419642677924e-06,1.248455451908992e-08,2.3825735875574433e-06,2.406942157177183e-06,2.3903298871433683e-06,2.3987959139049053e-06,168 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,structure/irreducible-warm,9.337619061616121e-09,5.7041846905397606e-11,9.294013636032869e-09,1.1644708423849735e-08,9.314520507411982e-09,9.424631230815466e-09,307 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,visits/bounded-expectation/k-10,5.086560503425722e-06,1.256642821490229e-08,5.078184272681882e-06,5.1113893352953e-06,5.083138459251841e-06,5.093905921438231e-06,152 +dtmc,absorbing-n0010-s01729,absorbing,10,1729,visits/bounded-expectation/k-100,3.685121024824035e-05,3.796748269320233e-08,3.682422864302301e-05,3.692376112391657e-05,3.684624835404657e-05,3.686893830215256e-05,130 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,absorption-time,1.7845874952163675e-05,4.394719866812182e-08,1.7807148642221132e-05,1.793528293035711e-05,1.783208352810973e-05,1.7857804221635245e-05,135 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,absorption/probabilities,1.8886987259305132e-05,1.056475749364435e-07,1.87976513928017e-05,1.9040013847579022e-05,1.8852843773572112e-05,1.89226231582108e-05,135 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,construction/public-consumed,6.342901696344428e-06,9.228228446788877e-09,6.332873097813592e-06,6.351788675060747e-06,6.340521559790988e-06,6.34519371842967e-06,173 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,evolution/k-10,1.6402511636358725e-06,2.5084623337121017e-09,1.6387995063917398e-06,1.6692144100136142e-06,1.639710819836965e-06,1.6412407882055457e-06,201 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,evolution/k-100,3.0513032898195775e-06,8.776127980864295e-09,3.0441156998441133e-06,3.071667785666944e-06,3.0487060019879786e-06,3.0532373011633536e-06,188 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,evolution/one-step,2.434613868377476e-07,8.943451105025969e-09,2.345063035930467e-07,2.5021650686802476e-07,2.4294567717132187e-07,2.440660079823044e-07,241 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,finite-time/n-step/k-10,2.9144985551919133e-06,8.302856940316446e-09,2.9073984141584755e-06,2.925694120328229e-06,2.9119843439750254e-06,2.917391628298403e-06,164 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,finite-time/n-step/k-100,1.7415543149489715e-05,1.808342252237124e-08,1.7399171958552897e-05,1.7434931675034603e-05,1.7409271436198996e-05,1.7421257382956492e-05,140 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,finite-time/observation/k-10,3.35677444929283e-06,1.3374434211033558e-08,3.3423945607960616e-06,3.3683653104133787e-06,3.3500573127386496e-06,3.360284038125446e-06,161 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,finite-time/observation/k-100,1.7884765451952338e-05,2.2588491813515296e-08,1.7866754684489185e-05,1.7918379732388227e-05,1.7877208860242203e-05,1.7892349703384354e-05,139 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,finite-time/step,7.52964470538895e-07,4.365390567243921e-09,7.497664940716814e-07,7.856496447540542e-07,7.519665544419051e-07,7.543333679410884e-07,191 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,fundamental-matrix,2.237405450697142e-05,9.158241947777703e-07,2.162146837300887e-05,2.4326865263238097e-05,2.1796146932645005e-05,2.355347836422187e-05,132 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,hitting-probability/cold-all-states,1.672892950188737e-05,5.3046017247440895e-08,1.6688083280604723e-05,1.6805268782975517e-05,1.6711141186020516e-05,1.6748048697731326e-05,136 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,hitting-probability/warm-lookup,2.378267532613675e-08,1.6689120286841173e-10,2.3636486235698998e-08,2.811138184260127e-08,2.370054405507598e-08,2.397216236200196e-08,288 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,hitting-time/cold-all-states,1.4866919476851852e-05,4.509111297824317e-08,1.482885677386477e-05,1.4918920454214764e-05,1.4854074247052957e-05,1.4884368953828112e-05,137 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,hitting-time/warm-lookup,2.4074656239830055e-08,1.8965920610742612e-10,2.390378750863578e-08,2.758064937428998e-08,2.3995334403003795e-08,2.415924799157828e-08,288 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,hitting/bounded/at-most/k-10,3.313117962659754e-06,2.088196051931958e-08,3.2948640792025224e-06,3.340979562882258e-06,3.304627830055731e-06,3.320892149153469e-06,161 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,hitting/bounded/at-most/k-100,1.9012299648614275e-05,1.978672629941993e-08,1.899637486013018e-05,1.9048209882407757e-05,1.900773195672493e-05,1.9018836136193574e-05,139 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,hitting/bounded/exact/k-10,3.257856323660828e-06,1.891326524369719e-08,3.2407407412093345e-06,3.287863236713385e-06,3.2536110448561287e-06,3.263624276705214e-06,162 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,hitting/bounded/exact/k-100,1.8776376579177504e-05,2.259408451649246e-08,1.8756632661810183e-05,1.880416281024326e-05,1.877035238459842e-05,1.878226267811107e-05,139 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,hitting/bounded/greater-than/k-10,3.271387830578029e-06,1.5323893607984203e-08,3.257769748583845e-06,3.288289676256654e-06,3.266554336906189e-06,3.2763010253244213e-06,162 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,hitting/bounded/greater-than/k-100,1.8982308053472012e-05,3.089249748975126e-08,1.8963350908372524e-05,1.9037943016830494e-05,1.8974949489347638e-05,1.899362127354405e-05,138 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,occupation-matrix,4.155798192150789e-05,7.740517461463656e-08,4.148403341952236e-05,4.168668386469386e-05,4.153814490859372e-05,4.1567179599978136e-05,125 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,power/10,4.407608724685143e-06,6.0577904567508896e-09,4.402978968287028e-06,4.423477920504439e-06,4.406535099777394e-06,4.40925184961828e-06,181 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,power/100,5.718749889638275e-06,1.0219544965749785e-08,5.708527761106381e-06,5.728841988483672e-06,5.716019427602731e-06,5.721797664392452e-06,175 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,power/2,3.35781059012035e-06,4.244601964694087e-09,3.3547139343630804e-06,3.3671459863820763e-06,3.356840613619507e-06,3.3587864785445166e-06,186 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,return/bounded/k-10,2.9870540372090424e-06,1.3428237661838927e-08,2.9769056719414307e-06,3.0134179280885756e-06,2.982434092569221e-06,2.9928753267288103e-06,163 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,return/bounded/k-100,1.8408255933506112e-05,1.5560013401668115e-08,1.8394009636768384e-05,1.843107153609679e-05,1.8403598610651594e-05,1.841412181881648e-05,139 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,stationary,5.478845129315341e-06,1.3262891266229767e-08,5.465746259421089e-06,5.492046781670383e-06,5.476299492003014e-06,5.481775516542527e-06,151 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,structure/classes-cold,3.383745715439401e-06,1.2650955587003965e-08,3.37416510918751e-06,3.405982072258161e-06,3.3803357595500864e-06,3.3883251911433635e-06,161 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,structure/classes-lifecycle,8.647367489310479e-06,1.0245521623368584e-08,8.639584278041508e-06,8.669849352293607e-06,8.645596608403139e-06,8.651867701202472e-06,167 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,structure/classes-warm/access,8.623125214662869e-09,1.349859886156147e-10,8.50486996513758e-09,1.0879620595449207e-08,8.549696332490192e-09,8.71599432400985e-09,308 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,structure/classes-warm/consumed,4.397113445978719e-08,2.319584228846713e-10,4.380400163221772e-08,4.7279550248492606e-08,4.38974062821657e-08,4.412740348160326e-08,275 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,structure/irreducible-cold,2.28301106495455e-06,6.488324053137615e-09,2.27770920512302e-06,2.296258279467734e-06,2.281957952591526e-06,2.2838758304112307e-06,169 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,structure/irreducible-warm,9.423772694752221e-09,1.0558940115419081e-10,9.332318066911933e-09,1.1975167200379712e-08,9.37077361777729e-09,9.5170248617219e-09,307 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,visits/bounded-expectation/k-10,5.120828789788194e-06,2.2033305867807242e-08,5.101159440390632e-06,5.155247756398895e-06,5.112314684987531e-06,5.129038200537342e-06,152 +dtmc,absorbing-n0010-s02718,absorbing,10,2718,visits/bounded-expectation/k-100,3.688305180439764e-05,3.385781833857674e-08,3.6861935219459477e-05,3.696085394848423e-05,3.687349501983477e-05,3.6899453404403995e-05,130 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,absorption-time,1.7670261592644714e-05,7.51447311232095e-08,1.759747578550204e-05,1.7747629148942557e-05,1.7639883581254327e-05,1.769646119084141e-05,135 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,absorption/probabilities,1.8569846165169462e-05,5.31047193486856e-08,1.8534538289593257e-05,1.865706139249275e-05,1.8555168824800806e-05,1.8586630176287144e-05,135 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,construction/public-consumed,6.3546890678557275e-06,8.394267040725613e-09,6.347640875377497e-06,6.3682467340590625e-06,6.352605999146271e-06,6.355765677180646e-06,173 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,evolution/k-10,1.6406250468112136e-06,2.346656943095176e-09,1.6388450615322246e-06,1.6492346304050665e-06,1.6402913254128324e-06,1.6409824343912884e-06,201 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,evolution/k-100,3.0445753268535916e-06,8.673699514861574e-09,3.037126326218842e-06,3.058114725695037e-06,3.0425724327105326e-06,3.0463749991877692e-06,188 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,evolution/one-step,2.4628940535144416e-07,1.1509621154908327e-08,2.3478216317382582e-07,2.5817404738391594e-07,2.441083038567948e-07,2.474489631321357e-07,241 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,finite-time/n-step/k-10,2.914384873047217e-06,8.428766340560555e-09,2.9067773611126e-06,2.9245238565069554e-06,2.9122744211872116e-06,2.9167067091975116e-06,164 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,finite-time/n-step/k-100,1.737006943330659e-05,2.2067860946794004e-08,1.7348515744324835e-05,1.7397820430814658e-05,1.7360770346314302e-05,1.7377031152136622e-05,140 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,finite-time/observation/k-10,3.363438904321251e-06,1.713822322377813e-08,3.3468911329003923e-06,3.380863038021036e-06,3.3589446341947596e-06,3.367017550197871e-06,161 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,finite-time/observation/k-100,1.7929183433208758e-05,3.381671838934407e-08,1.7902020920557942e-05,1.7968701688553183e-05,1.7918001357165557e-05,1.7939756179219802e-05,139 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,finite-time/step,7.500165282229407e-07,3.1250779945808303e-09,7.476515265798398e-07,7.545377733396162e-07,7.493536088492535e-07,7.515671782563862e-07,191 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,fundamental-matrix,2.1377971701229505e-05,1.1630309873672222e-07,2.12805142982161e-05,2.1667862003798495e-05,2.1354751960184853e-05,2.1409046880298876e-05,133 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,hitting-probability/cold-all-states,1.6569965574626436e-05,1.1504054769047625e-07,1.6485979924741705e-05,1.6766525732236914e-05,1.6533040175508227e-05,1.6608658492178016e-05,136 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,hitting-probability/warm-lookup,2.3794923513055166e-08,1.8271767588670913e-10,2.363734386836392e-08,2.7388138169021045e-08,2.370171973043617e-08,2.4037583788294858e-08,288 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,hitting-time/cold-all-states,1.4612626998584617e-05,5.717762795831985e-08,1.456960480458005e-05,1.4782033880085994e-05,1.4601566554096055e-05,1.4649464689794775e-05,137 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,hitting-time/warm-lookup,2.4050017563959594e-08,1.7026609115759607e-10,2.3903113113747606e-08,2.7050453379853675e-08,2.3985568911147798e-08,2.4212286792432833e-08,288 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,hitting/bounded/at-most/k-10,3.391235083846394e-06,1.1423696781116412e-08,3.383867398962526e-06,3.4143870127283863e-06,3.3874114728646937e-06,3.3956207367373824e-06,161 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,hitting/bounded/at-most/k-100,1.9038131854279664e-05,2.8657848881956773e-08,1.901547852729064e-05,1.908424713871103e-05,1.9027546224459983e-05,1.9050315849630063e-05,139 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,hitting/bounded/exact/k-10,3.2662212863086466e-06,1.2431514711253406e-08,3.2577819398542338e-06,3.2927269785432146e-06,3.263322778321137e-06,3.2701338256818162e-06,161 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,hitting/bounded/exact/k-100,1.8800096433692164e-05,2.3567889925239457e-08,1.878146954223211e-05,1.8834478359222086e-05,1.8795068798590027e-05,1.880695996765216e-05,138 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,hitting/bounded/greater-than/k-10,3.301060815912663e-06,1.8204349497723856e-08,3.2844552362544757e-06,3.323512252256672e-06,3.295866675519695e-06,3.3081581215802938e-06,161 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,hitting/bounded/greater-than/k-100,1.897345331775385e-05,3.491212964749457e-08,1.894807005975143e-05,1.9168395744616233e-05,1.896456855385492e-05,1.8981113212131303e-05,139 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,occupation-matrix,4.1328664290057005e-05,6.942412938702914e-08,4.128259190052162e-05,4.153613311549028e-05,4.131537571083754e-05,4.134865605738014e-05,125 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,power/10,4.368868924057833e-06,8.529882645929306e-09,4.361565803073493e-06,4.3815490761408015e-06,4.367513052336332e-06,4.371898260346566e-06,181 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,power/100,5.685390193007222e-06,1.4159678431447944e-08,5.6748996901464825e-06,5.7122691851608785e-06,5.6812616507077525e-06,5.6885176656749886e-06,176 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,power/2,3.3156610093306086e-06,8.117728779044908e-09,3.3104363196927288e-06,3.3793297405950558e-06,3.3143634865374364e-06,3.3227678284032876e-06,186 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,return/bounded/k-10,3.001561334237855e-06,1.241947359552165e-08,2.9923703048525943e-06,3.025499857980513e-06,2.9966002067197564e-06,3.010617508027958e-06,163 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,return/bounded/k-100,1.8431076974733374e-05,2.7640219309795367e-08,1.8408431522063088e-05,1.8464814288461947e-05,1.8423584500380428e-05,1.844159996835515e-05,139 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,stationary,5.589614357562546e-06,2.7264831423986308e-08,5.5689329293855335e-06,5.679296597446571e-06,5.577981485271824e-06,5.598089594316597e-06,150 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,structure/classes-cold,3.5168060585158165e-06,9.500639009396098e-09,3.5087741612945442e-06,3.5283085560818266e-06,3.5148485491437644e-06,3.5203813743638864e-06,160 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,structure/classes-lifecycle,8.674264144527274e-06,1.3229811549215286e-08,8.666564470972905e-06,8.711399881354244e-06,8.671804915231847e-06,8.678664569374575e-06,167 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,structure/classes-warm/access,8.573892692236574e-09,6.836317637308067e-11,8.524042599068121e-09,1.1270498103701351e-08,8.553903358586356e-09,8.646782940596894e-09,309 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,structure/classes-warm/consumed,4.4374253606389645e-08,4.953019258094057e-10,4.394311280385001e-08,4.8207619646022994e-08,4.417011816808111e-08,4.460623647297751e-08,275 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,structure/irreducible-cold,2.39768637487071e-06,7.121679815344256e-09,2.391840617120835e-06,2.407372738960568e-06,2.3957938675118513e-06,2.4006179994606272e-06,168 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,structure/irreducible-warm,9.445732462502839e-09,1.2602244930408003e-10,9.33079046305555e-09,1.2003939065829164e-08,9.383410343833008e-09,9.49517481021848e-09,307 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,visits/bounded-expectation/k-10,5.113272954586842e-06,1.8594508765522653e-08,5.097659155599398e-06,5.154610178642702e-06,5.10536647526085e-06,5.119189650463373e-06,152 +dtmc,absorbing-n0010-s31415,absorbing,10,31415,visits/bounded-expectation/k-100,3.69063125721684e-05,3.7295379697578976e-08,3.6877368259470775e-05,3.6975427052621636e-05,3.6898572284701295e-05,3.691312589242977e-05,130 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,absorption-time,5.326752771476382e-05,7.367327463461579e-08,5.3204693061529656e-05,5.334665834101194e-05,5.323411746003367e-05,5.328803442688169e-05,109 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,absorption/probabilities,5.085103082478731e-05,7.36988978867185e-08,5.079277681430704e-05,5.0972418930488416e-05,5.0828534176753254e-05,5.0882646447518743e-05,110 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,construction/public-consumed,3.717434217258798e-05,7.569759813747423e-08,3.711313289800907e-05,3.728219888382062e-05,3.7159275112119014e-05,3.719424929595479e-05,137 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,evolution/k-10,2.322089871304098e-06,5.466696360863658e-09,2.3187819618868827e-06,2.3378700561939395e-06,2.321630450402311e-06,2.322893828856157e-06,194 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,evolution/k-100,8.807692823564926e-06,5.2159527260481627e-08,8.733043892254285e-06,8.840756754265941e-06,8.79630901174723e-06,8.81662415715572e-06,167 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,evolution/one-step,3.960601129197602e-07,9.300835235361044e-09,3.8673928426849137e-07,4.028705340952356e-07,3.874865744083729e-07,3.9692543089295456e-07,231 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,finite-time/n-step/k-10,3.706039225448008e-06,1.2972688067789476e-08,3.694152656978447e-06,3.7223388654117946e-06,3.7015890814807606e-06,3.7091672891241516e-06,159 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,finite-time/n-step/k-100,2.42401225258176e-05,4.835466176583891e-08,2.4208224384798122e-05,2.4404036451849845e-05,2.4228229518642674e-05,2.4258958019742967e-05,122 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,finite-time/observation/k-10,4.526901668121182e-06,1.7481867882285418e-08,4.514281438920701e-06,4.560862735536475e-06,4.521821569409508e-06,4.534171845686312e-06,155 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,finite-time/observation/k-100,2.5018521244386714e-05,3.605381397386387e-08,2.4994318003088914e-05,2.506257424101932e-05,2.501050039427355e-05,2.5029220290743563e-05,121 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,finite-time/step,8.102420014059339e-07,7.01468229385378e-09,8.034720819692864e-07,8.177440950052735e-07,8.08027233710665e-07,8.119783086265076e-07,190 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,fundamental-matrix,7.281929645948682e-05,2.516714882162623e-07,7.264335007453992e-05,7.660894679448374e-05,7.268427073557966e-05,7.341637319768779e-05,107 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,hitting-probability/cold-all-states,4.520419535083035e-05,1.1541743351048877e-07,4.510133763539844e-05,4.536106210122983e-05,4.5156854575554146e-05,4.525410385509388e-05,110 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,hitting-probability/warm-lookup,2.3796597280043117e-08,1.7670421505711463e-10,2.363790540722293e-08,2.6972359386753063e-08,2.369180284072461e-08,2.3959803741151047e-08,288 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,hitting-time/cold-all-states,4.227333177023495e-05,5.942413041792085e-08,4.222374894694423e-05,4.238704931075341e-05,4.225500310031414e-05,4.229862774578082e-05,110 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,hitting-time/warm-lookup,2.4063393701833403e-08,1.779095826441569e-10,2.3911716097242544e-08,2.7050468108512813e-08,2.3988884342581695e-08,2.421824542195109e-08,288 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,hitting/bounded/at-most/k-10,4.647664783713583e-06,2.7220928964013143e-07,4.374018275796496e-06,4.816001338553742e-06,4.513276874317456e-06,4.665307917732846e-06,155 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,hitting/bounded/at-most/k-100,2.556689703072022e-05,3.588757091808076e-08,2.5536493018727386e-05,2.5643592514960027e-05,2.5557034470174195e-05,2.5578793847920655e-05,121 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,hitting/bounded/exact/k-10,4.238411063678974e-06,1.4898682698573209e-08,4.22668048848898e-06,4.27704149171852e-06,4.23574337810075e-06,4.241424053818431e-06,156 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,hitting/bounded/exact/k-100,2.5125719419020312e-05,3.1252048559880026e-08,2.5094944349904028e-05,2.5163536730150765e-05,2.5113665482682075e-05,2.5135843862472882e-05,121 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,hitting/bounded/greater-than/k-10,4.261128740858162e-06,1.213305838944258e-08,4.25121418370447e-06,4.2796247792567415e-06,4.257404555244161e-06,4.266241314923426e-06,156 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,hitting/bounded/greater-than/k-100,2.5504967212183678e-05,2.2492680009241042e-08,2.5482825650316146e-05,2.5527713493116803e-05,2.5497296545823254e-05,2.551268231269277e-05,121 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,occupation-matrix,0.00019637818578472835,1.823654156529156e-07,0.0001962227047903351,0.0001967084296796072,0.0001963101261751461,0.0001964609620352328,95 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,power/10,1.6471503888430735e-05,5.951847333936588e-08,1.6427627401821363e-05,1.655463360779458e-05,1.6461312497995095e-05,1.6487371614566444e-05,154 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,power/100,2.0111694822187536e-05,9.953209920060126e-08,2.003702237138076e-05,2.0304037087925552e-05,2.0081232911987107e-05,2.0143206059773018e-05,150 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,power/2,1.321753049637126e-05,1.7090170050386533e-08,1.3205577420558302e-05,1.328345301555514e-05,1.3214552843357242e-05,1.3222400104766758e-05,158 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,return/bounded/k-10,3.7877999880834585e-06,2.164542024215586e-08,3.764857422760978e-06,3.8039568269343004e-06,3.7814929263002004e-06,3.7916232240601307e-06,158 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,return/bounded/k-100,2.475726316483768e-05,2.749055226490424e-08,2.4733252939768135e-05,2.4796276799558353e-05,2.4748299149573295e-05,2.4764435416411448e-05,121 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,stationary,1.4093240586221445e-05,2.563368838561729e-08,1.4066310114398168e-05,1.4117850096244702e-05,1.4085901923941875e-05,1.4098791036451456e-05,132 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,structure/classes-cold,1.0490314943362372e-05,2.2289931742736706e-08,1.046557586700406e-05,1.0507957885479384e-05,1.0479230510171356e-05,1.049588862666287e-05,137 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,structure/classes-lifecycle,4.9839234818527214e-05,7.091679325893529e-08,4.9769461417877896e-05,4.991303456183021e-05,4.9811435867389986e-05,4.986733851897478e-05,131 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,structure/classes-warm/access,8.609630174270288e-09,9.616699384373307e-11,8.526768135751307e-09,1.1014378089029557e-08,8.580505590674636e-09,8.653072903553331e-09,309 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,structure/classes-warm/consumed,1.1378005936423166e-07,5.684062825335298e-10,1.1333625303214913e-07,1.1744790025261359e-07,1.1354987020665423e-07,1.1404697584617031e-07,256 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,structure/irreducible-cold,8.187831394177266e-06,1.4099604040030188e-08,8.175076489343297e-06,8.207285617541418e-06,8.185429554764209e-06,8.192650765609232e-06,142 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,structure/irreducible-warm,9.501187722664226e-09,1.7192192778795782e-10,9.34191143709174e-09,1.1852975451664987e-08,9.413574955663537e-09,9.579077854552954e-09,307 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,visits/bounded-expectation/k-10,6.086582548339275e-06,1.382527263178659e-08,6.069657663904028e-06,6.097218526216845e-06,6.0831135748469005e-06,6.08877401221208e-06,149 +dtmc,absorbing-n0025-s01729,absorbing,25,1729,visits/bounded-expectation/k-100,4.342124235945671e-05,8.268022131756303e-08,4.3366379288593586e-05,4.379095308425065e-05,4.3405005887803566e-05,4.343592333428275e-05,116 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,absorption-time,5.35337442651074e-05,9.239726432478757e-08,5.346556288502134e-05,5.3703398307148674e-05,5.351029002391126e-05,5.3559070996319256e-05,109 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,absorption/probabilities,5.126391593625124e-05,1.1379272159355816e-07,5.115786377362912e-05,5.1384048863986446e-05,5.122284709315042e-05,5.130057939310375e-05,110 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,construction/public-consumed,3.7135393260664236e-05,1.0973914083079118e-07,3.704381028882212e-05,3.7298607258846806e-05,3.710126484230418e-05,3.719820099924379e-05,137 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,evolution/k-10,2.3265404262587084e-06,4.865456365629816e-09,2.3229209711422462e-06,2.351844411021792e-06,2.325313114778186e-06,2.328565670079788e-06,194 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,evolution/k-100,8.720799098450006e-06,5.6496183861621006e-08,8.660623199706977e-06,8.772847362660054e-06,8.704490375945464e-06,8.731034799093298e-06,167 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,evolution/one-step,3.976573842252698e-07,1.0561693660435464e-08,3.871601406566688e-07,4.101159656640824e-07,3.901183014287093e-07,4.007652988752388e-07,231 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,finite-time/n-step/k-10,3.745169201066641e-06,1.123278351474024e-08,3.735095070046735e-06,3.76082380150799e-06,3.7403935936805297e-06,3.7482562304495395e-06,159 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,finite-time/n-step/k-100,2.4254304068755548e-05,3.782180394020602e-08,2.422508237439866e-05,2.430889714490219e-05,2.4240901921605328e-05,2.4266240668819388e-05,122 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,finite-time/observation/k-10,4.536376649104269e-06,2.5555805207934626e-08,4.514851515641962e-06,4.569151062168477e-06,4.529941599236473e-06,4.546529346364824e-06,154 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,finite-time/observation/k-100,2.518329531884492e-05,7.554788593658245e-08,2.5113937609055556e-05,2.526498636663226e-05,2.5159968465550594e-05,2.52160362261175e-05,120 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,finite-time/step,8.215414094602476e-07,6.9082754875335195e-09,8.142428207638042e-07,8.276754315795944e-07,8.193669297421972e-07,8.22763669922635e-07,190 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,fundamental-matrix,7.298247773956129e-05,1.0770281601318226e-07,7.289193058725284e-05,7.31169271393874e-05,7.294561186831238e-05,7.30335044847653e-05,107 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,hitting-probability/cold-all-states,4.54200005486583e-05,9.05821030915935e-08,4.5338616754044034e-05,4.555839987006038e-05,4.5387077822026144e-05,4.543947712094946e-05,109 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,hitting-probability/warm-lookup,2.5385629989486006e-08,1.3869907268262628e-09,2.5005707674740207e-08,2.891746040722331e-08,2.522041623808566e-08,2.5640945969434393e-08,288 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,hitting-time/cold-all-states,4.2549487426184086e-05,9.035985491620449e-08,4.248367778862986e-05,4.2729979065260916e-05,4.252620660129492e-05,4.260215553471202e-05,110 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,hitting-time/warm-lookup,2.4101145441519214e-08,2.2527301057639388e-10,2.3907705096117702e-08,2.7032183425035328e-08,2.4007169404469957e-08,2.436086503128544e-08,288 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,hitting/bounded/at-most/k-10,4.366365409133812e-06,1.177010585595042e-08,4.359134272254433e-06,4.387865030220455e-06,4.362700442369613e-06,4.369724620028439e-06,155 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,hitting/bounded/at-most/k-100,2.5576381068233223e-05,2.2030365869670637e-08,2.5557805275900178e-05,2.5604167118823775e-05,2.5569252255798625e-05,2.5585082866736266e-05,121 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,hitting/bounded/exact/k-10,4.296473826008926e-06,1.706452394801152e-08,4.282217771686872e-06,4.3254259908659e-06,4.289506617892797e-06,4.302444279186164e-06,156 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,hitting/bounded/exact/k-100,2.5271694049360636e-05,5.3847250793243284e-08,2.52317142038574e-05,2.5355844767406008e-05,2.526046279984127e-05,2.5283235382014195e-05,121 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,hitting/bounded/greater-than/k-10,4.296985240826636e-06,2.445715152264181e-08,4.27401147981747e-06,4.33218049659411e-06,4.290894790275681e-06,4.304601464573732e-06,156 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,hitting/bounded/greater-than/k-100,2.5541776790926072e-05,3.114085873853924e-08,2.5521652500365715e-05,2.5608702358356072e-05,2.5535942033154434e-05,2.5556673259170874e-05,121 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,occupation-matrix,0.0001973832784440472,7.797847354944681e-07,0.0001968430180750068,0.00021546895590891102,0.00019707552074072786,0.00019828370755986367,94 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,power/10,1.6649533601285976e-05,6.546413997032038e-08,1.6614502705651636e-05,1.680905814903914e-05,1.6641395903603207e-05,1.666777806646252e-05,152 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,power/100,2.0540286115362275e-05,1.3908242731776183e-07,2.0401840005872836e-05,2.0679368542680036e-05,2.0522304916805866e-05,2.056567794524954e-05,149 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,power/2,1.3339615273779552e-05,2.0984425261725588e-08,1.3325886794544991e-05,1.3388423965232282e-05,1.3335111111195552e-05,1.3345687877101134e-05,158 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,return/bounded/k-10,3.7872809363953946e-06,2.2448574647054617e-08,3.77172265816243e-06,3.854884475320274e-06,3.782828167838454e-06,3.7970875501227766e-06,158 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,return/bounded/k-100,2.4823133319624067e-05,2.775983526254132e-08,2.4800707829344792e-05,2.4856495799426397e-05,2.481347708501091e-05,2.4836302544070292e-05,122 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,stationary,1.4083305193873292e-05,2.2948621804200507e-08,1.4064333454526908e-05,1.4121865011623888e-05,1.4080020486296938e-05,1.4087383673400976e-05,131 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,structure/classes-cold,1.0499683138611108e-05,1.587914187755807e-08,1.0487739338816643e-05,1.0522134786610799e-05,1.0495774866717125e-05,1.0504994950881015e-05,137 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,structure/classes-lifecycle,4.998254852609769e-05,1.2582438885005482e-07,4.986461244437295e-05,5.019944465637694e-05,4.991359283276661e-05,5.002404911386157e-05,131 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,structure/classes-warm/access,8.650177968270308e-09,1.3023011685085267e-10,8.533173182465505e-09,1.0918670176831355e-08,8.595014842394709e-09,8.723647246149448e-09,309 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,structure/classes-warm/consumed,1.1409928624369444e-07,8.511970239503847e-10,1.1348568766502548e-07,1.1996574431501386e-07,1.1394927834929979e-07,1.1497231818977676e-07,255 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,structure/irreducible-cold,8.196249837055802e-06,2.054905053228133e-08,8.175297044917915e-06,8.21493352805137e-06,8.187253115465865e-06,8.20193469667555e-06,143 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,structure/irreducible-warm,9.471842588763196e-09,1.494170849327306e-10,9.334093959236936e-09,1.1799930616271222e-08,9.386382406073828e-09,9.518047261158849e-09,307 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,visits/bounded-expectation/k-10,6.086905920469411e-06,1.3994613426242265e-08,6.071759142085082e-06,6.099634386953738e-06,6.083330588166239e-06,6.089897686871444e-06,149 +dtmc,absorbing-n0025-s02718,absorbing,25,2718,visits/bounded-expectation/k-100,4.342475318851727e-05,3.574581198548195e-08,4.339437213724456e-05,4.346148246744027e-05,4.3416444034563756e-05,4.343926108903157e-05,117 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,absorption-time,5.369958727988393e-05,1.1480618800453686e-07,5.3588734590448436e-05,5.383884998886986e-05,5.365908059493926e-05,5.373437876080382e-05,109 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,absorption/probabilities,5.11383373556718e-05,8.868637787936813e-08,5.106917118305374e-05,5.131195027955155e-05,5.111604696139693e-05,5.115950751669744e-05,110 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,construction/public-consumed,3.7153030443926664e-05,6.74696845873567e-08,3.709876809040567e-05,3.7290322530503956e-05,3.7139896083584895e-05,3.718656523193678e-05,137 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,evolution/k-10,2.3167890371923785e-06,5.265582176723321e-09,2.313716329036989e-06,2.3533149992358193e-06,2.3161254241778897e-06,2.3205686605725647e-06,193 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,evolution/k-100,9.876936216596606e-06,6.379539694602572e-07,8.912304337940105e-06,1.0328114085674145e-05,9.724805204314178e-06,9.961408521995053e-06,166 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,evolution/one-step,3.955761346067283e-07,8.985490183013513e-09,3.865502574701953e-07,4.037667287977056e-07,3.884023524708681e-07,3.964964827285515e-07,231 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,finite-time/n-step/k-10,3.72443497092723e-06,7.79080778179146e-09,3.71709693423883e-06,3.7351860305610435e-06,3.7225752584099648e-06,3.7260557700026885e-06,159 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,finite-time/n-step/k-100,2.417753395530646e-05,2.4138202579841267e-08,2.4161230929543633e-05,2.4215969433885345e-05,2.4171310590893383e-05,2.4185421902061078e-05,122 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,finite-time/observation/k-10,4.48531335305262e-06,9.516787534608749e-09,4.47779019941054e-06,4.499363794009137e-06,4.482819988104462e-06,4.488877697885797e-06,155 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,finite-time/observation/k-100,2.4921937260006993e-05,3.046994630622951e-08,2.489823414033444e-05,2.497644927643705e-05,2.4913194623926804e-05,2.493635738888451e-05,121 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,finite-time/step,8.226025018182846e-07,6.7110103283503595e-09,8.162524330090131e-07,8.301781696027394e-07,8.197060932606076e-07,8.246254780028587e-07,190 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,fundamental-matrix,7.28186847450081e-05,7.548240932918706e-08,7.275421446369161e-05,7.297760370079896e-05,7.277754484675824e-05,7.286114743220862e-05,107 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,hitting-probability/cold-all-states,4.536117810436037e-05,9.87954216016975e-08,4.528072614768591e-05,4.552698356127351e-05,4.532660103984004e-05,4.5438410533592765e-05,110 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,hitting-probability/warm-lookup,2.45432949941715e-08,9.100214536932677e-10,2.3640502311940615e-08,2.7574620473324474e-08,2.378919838449935e-08,2.474601159833941e-08,288 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,hitting-time/cold-all-states,4.258529224509369e-05,7.962235775479587e-08,4.252198009928857e-05,4.2748479765058225e-05,4.2557905317400574e-05,4.2609549379142627e-05,110 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,hitting-time/warm-lookup,2.402713604948171e-08,1.6000984333194664e-10,2.389150519968259e-08,2.7042519075146713e-08,2.394955228957005e-08,2.4227717623101017e-08,288 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,hitting/bounded/at-most/k-10,4.314144533698906e-06,6.503119006883675e-09,4.30966492212839e-06,4.327415538119524e-06,4.3130946679688664e-06,4.31648759650174e-06,156 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,hitting/bounded/at-most/k-100,2.547560133615453e-05,2.4384458084734088e-08,2.545702712017833e-05,2.550055588861661e-05,2.5468256178309198e-05,2.548214459758518e-05,121 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,hitting/bounded/exact/k-10,4.230792904798936e-06,1.4557073969668352e-08,4.2188226820423034e-06,4.246282690932191e-06,4.22824332665351e-06,4.235210121065254e-06,156 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,hitting/bounded/exact/k-100,2.5120753823590558e-05,5.083726992167941e-08,2.508693135901468e-05,2.5234997987614145e-05,2.5099384956043108e-05,2.5144247076835254e-05,121 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,hitting/bounded/greater-than/k-10,4.24571765933604e-06,1.324142333981496e-08,4.2337871721725835e-06,4.263665665607355e-06,4.24195349463377e-06,4.248885850966043e-06,156 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,hitting/bounded/greater-than/k-100,2.5471677730500424e-05,3.366282784327565e-08,2.544539538473728e-05,2.5515080257423973e-05,2.546270641020814e-05,2.548670254063968e-05,121 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,occupation-matrix,0.0001964864616009156,9.329884771672897e-08,0.00019641692325523895,0.0001967086068642788,0.0001964573978423892,0.0001965512693949187,95 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,power/10,1.6377828968356513e-05,2.7942074930318445e-08,1.635288540423896e-05,1.640977291472476e-05,1.637014007760522e-05,1.6384433849339945e-05,154 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,power/100,2.0243182554165404e-05,9.842108522503116e-08,2.0149716254888214e-05,2.0368975520906437e-05,2.0220177791280175e-05,2.027119254130046e-05,150 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,power/2,1.3200720051097837e-05,2.5245616361185513e-08,1.318758737366141e-05,1.3321295045759132e-05,1.3196402278830126e-05,1.3209446694024303e-05,158 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,return/bounded/k-10,3.7707694202148613e-06,1.2512904207648536e-08,3.7599938509604726e-06,3.786950431968664e-06,3.768233355892738e-06,3.7745323939377376e-06,159 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,return/bounded/k-100,2.474902957512307e-05,2.7014493876515485e-08,2.4727360112592577e-05,2.479172334015528e-05,2.473923684762775e-05,2.4758563848049508e-05,121 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,stationary,1.408719828719752e-05,3.2336523393529096e-08,1.4060729998760927e-05,1.4141065150751382e-05,1.4075092147297385e-05,1.4098797961465877e-05,132 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,structure/classes-cold,1.0468200372427008e-05,1.8791943167523455e-08,1.0452739525221875e-05,1.0492394692433702e-05,1.0463185239372352e-05,1.0472394563092486e-05,138 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,structure/classes-lifecycle,4.987960859277902e-05,6.2479058661691e-08,4.981986943713534e-05,4.995062507905479e-05,4.986258077566203e-05,4.9896950908337855e-05,131 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,structure/classes-warm/access,9.138011322321274e-09,6.018592312854638e-10,8.562971724587184e-09,1.1375577523517775e-08,9.006555253176189e-09,9.191044312561405e-09,307 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,structure/classes-warm/consumed,1.1362242453172497e-07,4.2225309367046195e-10,1.1332590387163928e-07,1.2155631783953016e-07,1.1351268030108654e-07,1.1395340973467032e-07,256 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,structure/irreducible-cold,8.184665118019834e-06,1.0935703616783764e-08,8.176159055057036e-06,8.200247890964916e-06,8.182442993496985e-06,8.189839518665537e-06,143 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,structure/irreducible-warm,9.428355322072654e-09,1.0399893079312853e-10,9.334062465575047e-09,1.1986731944802677e-08,9.382254182616145e-09,9.529896505992088e-09,307 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,visits/bounded-expectation/k-10,6.093674071370412e-06,1.3158501700050134e-08,6.083608689326523e-06,6.117453625792581e-06,6.0902733048405215e-06,6.096785625531155e-06,149 +dtmc,absorbing-n0025-s31415,absorbing,25,31415,visits/bounded-expectation/k-100,4.3280836351899885e-05,3.5579718381110233e-08,4.325944691016856e-05,4.3352082671342016e-05,4.327677821248162e-05,4.3296152569751754e-05,117 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,absorption-time,0.0001696131460318741,2.560024898100267e-07,0.00016940072040712935,0.0001700322536656298,0.00016948824853479732,0.00016973525800527504,83 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,absorption/probabilities,0.0001476812579367496,1.1281214635043004e-07,0.00014757889169102003,0.00014781662520760929,0.00014763919781576442,0.00014771273233702196,86 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,construction/public-consumed,0.00014513341837077952,2.412546008066102e-07,0.00014490131549169555,0.0001453761279220579,0.00014505866662754366,0.0001452137404636885,109 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,evolution/k-10,4.394704785270908e-06,9.559692035945308e-09,4.3873331271662445e-06,4.411380751452481e-06,4.392837825533305e-06,4.396272521785491e-06,181 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,evolution/k-100,2.0549704077656718e-05,2.4924684162568213e-08,2.05310810407674e-05,2.059166759236491e-05,2.0545564962852563e-05,2.0553330781553096e-05,149 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,evolution/one-step,8.099314944869647e-07,2.2230748646249102e-08,7.36137534285671e-07,8.271276561522364e-07,8.068732096857968e-07,8.125404879433503e-07,217 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,finite-time/n-step/k-10,5.7737841215474475e-06,2.0083432784273802e-08,5.759132373620452e-06,6.226904050973562e-06,5.7712570325547025e-06,5.776557954760639e-06,150 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,finite-time/n-step/k-100,4.3359924802643945e-05,7.287970316346247e-08,4.329124896016604e-05,4.3436749968792406e-05,4.333582354079494e-05,4.339099373840525e-05,108 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,finite-time/observation/k-10,7.216395639867794e-06,1.0509433425680604e-08,7.206705592397053e-06,7.226999909819468e-06,7.214252980679415e-06,7.220798579510301e-06,145 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,finite-time/observation/k-100,4.481802560413988e-05,4.2779455088937134e-08,4.477795504335722e-05,4.487183570855643e-05,4.4805537061560055e-05,4.482860060378437e-05,108 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,finite-time/step,8.384310645223658e-07,3.8232609909448615e-09,8.349245315632568e-07,8.424519271850336e-07,8.372308474605828e-07,8.396891644224524e-07,189 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,fundamental-matrix,0.00023904293390411972,2.797714304078906e-07,0.00023876812158525292,0.00023931105593243156,0.00023894496293256192,0.0002391302492469549,83 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,hitting-probability/cold-all-states,0.00013615204658924118,1.2117608868587675e-07,0.0001360726633173026,0.00013633937624694806,0.0001361240474413398,0.00013623204590244725,85 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,hitting-probability/warm-lookup,2.4082610986097823e-08,4.6551874061114134e-10,2.3630551706828266e-08,2.7760951657002205e-08,2.3722260661695854e-08,2.4218811888947178e-08,288 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,hitting-time/cold-all-states,0.00013151927490529254,1.2184227523445658e-07,0.0001314223835244978,0.000131697893980797,0.00013147584266524987,0.00013156345406160409,86 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,hitting-time/warm-lookup,2.4034625084261487e-08,1.4993569392142923e-10,2.3907947434369518e-08,2.7194354791642543e-08,2.3993054844828156e-08,2.412869007082211e-08,288 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,hitting/bounded/at-most/k-10,6.825200814808831e-06,1.8011500724069044e-08,6.79987161012043e-06,6.838893144037706e-06,6.819284966095744e-06,6.829673909637808e-06,146 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,hitting/bounded/at-most/k-100,4.605166979037337e-05,5.702482867181604e-08,4.6012876598024846e-05,4.61429346231805e-05,4.6038300222410194e-05,4.606441965917548e-05,107 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,hitting/bounded/exact/k-10,6.712370916066027e-06,1.4486573481206963e-08,6.700992303534865e-06,6.732806689273495e-06,6.709592864362855e-06,6.715035667430998e-06,146 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,hitting/bounded/exact/k-100,4.5720999942497486e-05,8.15682772561794e-08,4.5647097849270324e-05,4.5815827540556054e-05,4.5693571467251915e-05,4.573415331345367e-05,107 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,hitting/bounded/greater-than/k-10,6.763927568739819e-06,1.5342627543366796e-08,6.7497190584888035e-06,6.7800180182607475e-06,6.759692601358088e-06,6.76964623809634e-06,147 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,hitting/bounded/greater-than/k-100,4.576551096321472e-05,5.302605773762015e-08,4.571834321586721e-05,4.5819722731942614e-05,4.5744755416765783e-05,4.577886162830206e-05,107 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,occupation-matrix,0.0007808816323155215,4.801093353538899e-07,0.0007805335037037381,0.0007815227689179597,0.0007807494542138363,0.0007810752518237656,68 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,power/10,4.6753601748365815e-05,6.395806737064571e-08,4.669940337796533e-05,4.685195076628633e-05,4.673090743737453e-05,4.677295315686152e-05,132 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,power/100,5.660752964543243e-05,1.3473665873849452e-07,5.6471833280132465e-05,5.673954215393785e-05,5.656416980409116e-05,5.666292213254837e-05,129 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,power/2,4.026128152330556e-05,2.8832729076019593e-08,4.0241949514263646e-05,4.0301083398218404e-05,4.0256513394914304e-05,4.026783133421539e-05,136 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,return/bounded/k-10,5.909038603077737e-06,1.0542962056118406e-08,5.899281618562905e-06,5.920490770626606e-06,5.907431700666142e-06,5.911654562973881e-06,149 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,return/bounded/k-100,4.4793247841348494e-05,4.3998756284194864e-08,4.475101361624296e-05,4.4843043190626725e-05,4.478228022671034e-05,4.481437811544425e-05,108 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,stationary,4.232237283998218e-05,6.392621011039415e-08,4.224994918331504e-05,4.2379247955977916e-05,4.230310948253035e-05,4.23398775248123e-05,109 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,structure/classes-cold,3.2961778602223776e-05,2.887649624501627e-08,3.293408089489242e-05,3.3013376198639166e-05,3.295371822497348e-05,3.297196876158083e-05,114 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,structure/classes-lifecycle,0.00019813996650735015,1.524196511337023e-07,0.0001980583920545302,0.000198388078731821,0.00019810784659551872,0.00019820881661393545,103 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,structure/classes-warm/access,8.561664154524594e-09,8.034203636385521e-11,8.494282126525375e-09,1.1135058627388943e-08,8.520654904479798e-09,8.831292209726397e-09,309 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,structure/classes-warm/consumed,2.474566962608455e-07,7.286265452318861e-09,2.4039236114712564e-07,2.695036818444859e-07,2.420526997142153e-07,2.56465403251766e-07,240 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,structure/irreducible-cold,2.8887233404780227e-05,4.2555171559828994e-08,2.884745536544925e-05,2.893597553778002e-05,2.887762112743186e-05,2.8900637080307336e-05,116 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,structure/irreducible-warm,9.400417743718657e-09,1.092839036720159e-10,9.316787018718836e-09,1.1825798756534278e-08,9.359544305210061e-09,9.545629211697293e-09,307 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,visits/bounded-expectation/k-10,8.346633559369956e-06,1.3458033711747043e-08,8.336334451117774e-06,8.370865213113245e-06,8.3424840315264e-06,8.352187584383172e-06,142 +dtmc,absorbing-n0050-s01729,absorbing,50,1729,visits/bounded-expectation/k-100,6.406191643171561e-05,8.545618598985885e-08,6.399554847445845e-05,6.416011183318915e-05,6.404282017187639e-05,6.408297973975105e-05,100 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,absorption-time,0.00016918961789976972,1.7578239899494774e-07,0.0001690269899583044,0.00016937290021728368,0.0001691459918779751,0.00016922157434751066,83 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,absorption/probabilities,0.00014731923908764915,1.377711463198709e-07,0.00014718033367423452,0.00014744943460215897,0.00014727460399188556,0.0001473787216258148,86 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,construction/public-consumed,0.00014505404170172325,1.415413016270814e-07,0.00014491250040009617,0.0001451827319467255,0.00014501470586230213,0.0001450912618782327,109 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,evolution/k-10,4.388205181017556e-06,7.321150250055751e-09,4.38130914101911e-06,4.396255053019238e-06,4.386873337991499e-06,4.389306958597016e-06,181 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,evolution/k-100,2.063595366990674e-05,4.09213800172989e-08,2.060624998800146e-05,2.0733460486452612e-05,2.0623109247774505e-05,2.065277943734591e-05,149 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,evolution/one-step,7.492208217958122e-07,1.4808471100657025e-08,7.343539341981075e-07,7.61417806884716e-07,7.357855242491841e-07,7.509110247683004e-07,218 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,finite-time/n-step/k-10,5.712089090194183e-06,1.085652632868206e-08,5.698928493249929e-06,5.720515704753313e-06,5.707581871819184e-06,5.715111551747307e-06,150 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,finite-time/n-step/k-100,4.316113432514232e-05,3.6134407630889983e-08,4.313279688189589e-05,4.320067295338959e-05,4.315276289292212e-05,4.317427241899581e-05,109 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,finite-time/observation/k-10,7.158033846387669e-06,6.860653324850883e-09,7.152550741794366e-06,7.16616579697747e-06,7.156448434515251e-06,7.160263131871554e-06,145 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,finite-time/observation/k-100,4.4635444448908194e-05,6.728105486708758e-08,4.4578816243116065e-05,4.475790017899721e-05,4.4612302603623405e-05,4.466248383668923e-05,107 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,finite-time/step,8.25094474222217e-07,7.557091724576685e-09,8.177403103307142e-07,8.327969065730405e-07,8.233926037478608e-07,8.269226572547967e-07,190 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,fundamental-matrix,0.00023857451030399968,2.2436608796281752e-07,0.00023838561977412333,0.00023888214936073794,0.00023852399978998372,0.00023868186293508518,83 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,hitting-probability/cold-all-states,0.00013632564361231695,1.7744335836092427e-07,0.00013615080665442205,0.0001365183886394204,0.00013625995339934042,0.00013639236246543827,85 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,hitting-probability/warm-lookup,2.3760906123637237e-08,1.4452725877874838e-10,2.363535824550955e-08,2.6959907580141466e-08,2.3698803859775022e-08,2.389554588767674e-08,288 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,hitting-time/cold-all-states,0.00013133435724665683,1.528309713656322e-07,0.00013118435549515722,0.00013149784658647454,0.0001312869274554766,0.00013139948434524138,86 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,hitting-time/warm-lookup,2.4058912179340415e-08,1.8417444389210866e-10,2.3904221134395083e-08,2.734693266151601e-08,2.398501668411675e-08,2.4236194863098302e-08,288 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,hitting/bounded/at-most/k-10,6.7481989801437704e-06,1.0723227024233863e-08,6.739659015279771e-06,6.761810038283113e-06,6.745742851037633e-06,6.752051654038541e-06,145 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,hitting/bounded/at-most/k-100,4.5925595612939576e-05,5.8767457136020974e-08,4.587710662528902e-05,4.599957861537239e-05,4.5913761832953946e-05,4.594714268441685e-05,107 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,hitting/bounded/exact/k-10,6.641838791123647e-06,1.398964855127014e-08,6.631446952757859e-06,6.666926097083075e-06,6.6394939600233584e-06,6.644668059736908e-06,147 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,hitting/bounded/exact/k-100,4.568162718358296e-05,4.752122178827234e-08,4.563050419785828e-05,4.5728230981958915e-05,4.566908566508842e-05,4.5701450939564635e-05,107 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,hitting/bounded/greater-than/k-10,6.7143439082428815e-06,1.862259326008848e-08,6.697300314526167e-06,6.7358641098898796e-06,6.7100258573783e-06,6.720857830039225e-06,147 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,hitting/bounded/greater-than/k-100,4.581506930176832e-05,8.093209120713427e-08,4.5746789279242826e-05,4.5916769662513754e-05,4.578144818173759e-05,4.583218260174335e-05,105 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,occupation-matrix,0.0007791410665293346,3.194253654295468e-07,0.0007788558076033162,0.0007795265104723596,0.000778996262369513,0.0007792796270223335,68 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,power/10,4.6991460066198406e-05,1.1517099839690462e-07,4.688788132105921e-05,4.710568834175336e-05,4.696414688127431e-05,4.701885788839824e-05,132 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,power/100,5.6811978037928635e-05,1.5789361172773811e-07,5.667468340204198e-05,5.7005036886985336e-05,5.676022342929869e-05,5.6876829426280196e-05,128 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,power/2,4.0371345116830286e-05,4.241520227621034e-08,4.0340368171949176e-05,4.042970832591147e-05,4.03587348118162e-05,4.0380923931706665e-05,136 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,return/bounded/k-10,5.847235057837215e-06,2.5436143458441475e-08,5.819717282999355e-06,5.87056947263172e-06,5.8389107648109135e-06,5.8525728822629895e-06,150 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,return/bounded/k-100,4.761693564233448e-05,1.1233091289418074e-06,4.4763265971518564e-05,4.800517282481971e-05,4.7371271681516765e-05,4.777509619671743e-05,108 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,stationary,4.2348076690799526e-05,5.793438104531118e-08,4.2301081342433806e-05,4.24162143283093e-05,4.232692963127605e-05,4.236751482097019e-05,109 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,structure/classes-cold,3.293836227002382e-05,4.534084442620723e-08,3.2900825432974786e-05,3.299999904508392e-05,3.292844280238367e-05,3.295068346638603e-05,113 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,structure/classes-lifecycle,0.00019871400995257363,1.5354094036891097e-07,0.00019859808456506776,0.00019890019655452944,0.00019868082526248418,0.0001987720070631017,103 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,structure/classes-warm/access,8.602295150125012e-09,8.694434876614002e-11,8.525778620003386e-09,1.0816923653086027e-08,8.571485883697462e-09,8.679620455088696e-09,309 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,structure/classes-warm/consumed,2.418658898973507e-07,8.446840978215823e-10,2.411667012399896e-07,2.479115243147359e-07,2.4153651154762064e-07,2.421645015543252e-07,240 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,structure/irreducible-cold,2.8894210140018113e-05,7.799151016872711e-08,2.8845909224456232e-05,2.900003649604817e-05,2.8880800205633585e-05,2.891677450538883e-05,117 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,structure/irreducible-warm,9.402046240221366e-09,8.732113035632494e-11,9.331034292485864e-09,1.194647526445045e-08,9.378273372682672e-09,9.495007749278217e-09,307 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,visits/bounded-expectation/k-10,8.328965164464908e-06,2.0280510756897912e-08,8.307955112628285e-06,8.347984448360556e-06,8.324325451742084e-06,8.336102553902959e-06,142 +dtmc,absorbing-n0050-s02718,absorbing,50,2718,visits/bounded-expectation/k-100,6.381255063852334e-05,4.123961587013656e-08,6.377919780788943e-05,6.386472833491423e-05,6.380043223789717e-05,6.382534346600663e-05,101 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,absorption-time,0.000169434432921532,2.732762423102381e-07,0.00016918728098935662,0.00016975731931678537,0.000169287082422266,0.00016957519082574262,83 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,absorption/probabilities,0.00014747985037011447,1.81302104032102e-07,0.00014732039528941125,0.0001476717208639664,0.00014741017556064304,0.00014753316393079313,86 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,construction/public-consumed,0.00014531794353857667,1.2823873461338653e-07,0.00014518366393167524,0.00014544578092906318,0.00014528256308819567,0.0001453671274976211,109 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,evolution/k-10,4.3936496364721495e-06,8.603212607624183e-09,4.388391513143029e-06,4.417321517496761e-06,4.392097879321853e-06,4.395886540616358e-06,180 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,evolution/k-100,2.0639449108525048e-05,3.523768375211751e-08,2.0615650066369134e-05,2.0806233029025923e-05,2.0632287487387657e-05,2.0657919793728e-05,149 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,evolution/one-step,7.48042664355586e-07,1.3739063727743767e-08,7.342481281610879e-07,7.596071353389479e-07,7.367651802183737e-07,7.499001297893407e-07,218 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,finite-time/n-step/k-10,5.7259941203611365e-06,3.0794376771974094e-08,5.713522260621732e-06,5.966439579893641e-06,5.721525537320689e-06,5.740866180346523e-06,150 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,finite-time/n-step/k-100,4.318132450862322e-05,5.043599230703048e-08,4.3146500088782474e-05,4.327076652164881e-05,4.3166096076472766e-05,4.3206800535735845e-05,109 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,finite-time/observation/k-10,7.162368617269777e-06,3.667547843981274e-08,7.123210317721325e-06,7.186805696287337e-06,7.143279536011508e-06,7.17277296205903e-06,145 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,finite-time/observation/k-100,4.477313579591996e-05,5.33466082267402e-08,4.472820751205677e-05,4.4844366389692626e-05,4.4753739908986467e-05,4.478716267728988e-05,108 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,finite-time/step,8.157724027524759e-07,6.952922165794528e-09,8.112335127786911e-07,8.304091135782766e-07,8.14755741671166e-07,8.185013479033176e-07,190 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,fundamental-matrix,0.00023884912905585323,2.0521879319284828e-07,0.00023870151495912625,0.00023906912505916478,0.00023879727285185999,0.00023892146110973464,83 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,hitting-probability/cold-all-states,0.00013662959207539206,2.0976830875874745e-07,0.00013646315559492236,0.0001370473599474115,0.00013657433726874287,0.0001366906181417967,85 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,hitting-probability/warm-lookup,2.388761638939848e-08,2.6640198202819223e-10,2.363720114232268e-08,2.7580252589173672e-08,2.373649950210295e-08,2.42643625708375e-08,288 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,hitting-time/cold-all-states,0.00013151642376974416,1.995429949450849e-07,0.0001313289852924056,0.00013174913577469332,0.00013142591062701372,0.00013159351040788655,86 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,hitting-time/warm-lookup,2.4220576982581403e-08,3.316124707719666e-10,2.390692724789377e-08,2.7602385966224752e-08,2.398163536599681e-08,2.4373158767192178e-08,288 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,hitting/bounded/at-most/k-10,6.7451878946841415e-06,8.617625514718305e-09,6.735936575311595e-06,6.7511825716607215e-06,6.74065183581963e-06,6.7468778191880395e-06,147 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,hitting/bounded/at-most/k-100,4.598584543395367e-05,4.8369142322005835e-08,4.594522302014632e-05,4.60691972780207e-05,4.596778396139475e-05,4.600913917574172e-05,107 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,hitting/bounded/exact/k-10,6.660802582515098e-06,1.0248781713457282e-08,6.6519194197277165e-06,6.6728620828451165e-06,6.658126145009716e-06,6.664249158535801e-06,146 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,hitting/bounded/exact/k-100,4.567002636842408e-05,5.2881856863132705e-08,4.5628715937103456e-05,4.573145971852719e-05,4.565336315532807e-05,4.568782931467089e-05,107 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,hitting/bounded/greater-than/k-10,6.73900261366119e-06,2.4163278057695337e-08,6.72149763883933e-06,6.768696847656327e-06,6.734557960693824e-06,6.747848555805678e-06,147 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,hitting/bounded/greater-than/k-100,4.578004545355388e-05,4.3023671859461726e-08,4.5746853335510224e-05,4.583236342303034e-05,4.576378670358325e-05,4.579268777035224e-05,107 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,occupation-matrix,0.0007805177726253761,5.68834407877535e-07,0.000779916969240616,0.000781065872974013,0.0007801219567597126,0.0007807523663639306,68 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,power/10,5.2263419035593047e-05,8.74322898785884e-07,5.0136000477200116e-05,5.29932068024789e-05,5.208607403447415e-05,5.239371432476126e-05,132 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,power/100,5.7275077603102854e-05,1.801253476902098e-07,5.712168414749181e-05,5.749009453766602e-05,5.722025277928561e-05,5.7318768926299385e-05,128 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,power/2,4.0382410962555606e-05,4.7893584536804184e-08,4.033824152567871e-05,4.044875292558255e-05,4.035705559443967e-05,4.039236449307358e-05,135 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,return/bounded/k-10,5.847822573338964e-06,1.4668414316065291e-08,5.835160229759268e-06,5.868880466064556e-06,5.842792906244144e-06,5.851098025605534e-06,150 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,return/bounded/k-100,4.45686245966851e-05,7.016619854291866e-08,4.4518774895886576e-05,4.468361215270682e-05,4.453866845067461e-05,4.4588343890999174e-05,108 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,stationary,4.23855285589525e-05,8.219127634669391e-08,4.2292580317695856e-05,4.245602799023295e-05,4.235731884886689e-05,4.2399365920573476e-05,109 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,structure/classes-cold,3.307665839316088e-05,3.3571354134754515e-08,3.304612140496085e-05,3.3110611999826156e-05,3.3068546372893945e-05,3.308584745771159e-05,114 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,structure/classes-lifecycle,0.00019912075516245118,3.9174480420746155e-07,0.00019867019417818354,0.00019938367845041927,0.00019900347224729894,0.000199241532602487,103 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,structure/classes-warm/access,8.59640622812186e-09,9.151744990170377e-11,8.523573495845894e-09,1.0814180259231498e-08,8.557065885292245e-09,8.684531257830131e-09,309 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,structure/classes-warm/consumed,2.4214305930269855e-07,1.1581014319402017e-09,2.411378036324364e-07,2.4712642976121176e-07,2.418188766265909e-07,2.429410020057791e-07,240 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,structure/irreducible-cold,2.8834675695584763e-05,5.063167286658554e-08,2.8789727366529405e-05,2.889763956631814e-05,2.8816587601435882e-05,2.8857107067113237e-05,117 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,structure/irreducible-warm,9.440871291618973e-09,1.2506884769846746e-10,9.337727931236883e-09,1.1964982654416678e-08,9.387791184020365e-09,9.531116596379603e-09,306 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,visits/bounded-expectation/k-10,8.285836642404803e-06,2.062399355353811e-08,8.268067528303417e-06,8.308081081343146e-06,8.281070455115955e-06,8.294872030339813e-06,142 +dtmc,absorbing-n0050-s31415,absorbing,50,31415,visits/bounded-expectation/k-100,6.40432077538794e-05,8.322273840465771e-08,6.399603300862223e-05,6.41604324687419e-05,6.402705535206392e-05,6.406487655643409e-05,100 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,absorption-time,0.0006136229522304521,2.005824214956287e-06,0.0006119387335584303,0.0006159317088241696,0.0006125888049912949,0.0006142659003949433,59 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,absorption/probabilities,0.000499890209959211,2.052019856189609e-06,0.0004979210260851113,0.0005019422298154006,0.0004991520623979528,0.00050107910647057,61 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,construction/public-consumed,0.000585647400112066,4.010778637555078e-07,0.0005851417983649299,0.0005860312503500609,0.0005854697999893687,0.0005858330838389215,81 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,evolution/k-10,1.0135685351235582e-05,1.6018115000770904e-08,1.0123292162508709e-05,1.016194569179501e-05,1.0133752381659278e-05,1.013859436981873e-05,164 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,evolution/k-100,9.517789139145643e-05,1.0004604471185543e-07,9.507534474947507e-05,9.526658851384473e-05,9.515824271774914e-05,9.521108952275796e-05,118 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,evolution/one-step,1.6136632699696646e-06,9.966692272924174e-09,1.605019701697796e-06,1.6461513654542734e-06,1.6072382159641914e-06,1.617444768956615e-06,202 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,finite-time/n-step/k-10,1.1887001499359872e-05,3.22133496886737e-08,1.1858783138796708e-05,1.1921532614313493e-05,1.1879948115992276e-05,1.1896024574549594e-05,135 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,finite-time/n-step/k-100,9.728484448550596e-05,1.332204003979176e-07,9.717492113514895e-05,9.746714181233155e-05,9.725177059434942e-05,9.731704360056741e-05,92 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,finite-time/observation/k-10,1.4500081306323409e-05,6.247959707094349e-08,1.4465611807532907e-05,1.4650838992502775e-05,1.4486601576209069e-05,1.4524042428015394e-05,131 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,finite-time/observation/k-100,9.987591610573338e-05,9.615383326668891e-08,9.980208001394643e-05,0.00010002291923445583,9.984571284062609e-05,9.990660979989723e-05,88 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,finite-time/step,8.736160232098971e-07,9.74055329495744e-09,8.659710699765051e-07,9.089851970448501e-07,8.721840761912366e-07,8.760746216017836e-07,188 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,fundamental-matrix,0.0008907273467312651,1.66824688183141e-06,0.0008896746148820966,0.0008944707504789611,0.0008902057298021673,0.0008914990679575445,57 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,hitting-probability/cold-all-states,0.00046134863332554233,8.751746362476364e-07,0.00046044001515702863,0.0004620810569576861,0.0004608892046565994,0.0004616806467718291,60 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,hitting-probability/warm-lookup,2.3882750157986394e-08,2.5259942293393357e-10,2.3655831804120987e-08,2.7248084632261828e-08,2.383850312906104e-08,2.4025612908057133e-08,288 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,hitting-time/cold-all-states,0.0004532677142248888,5.061263727227771e-07,0.0004528056642739102,0.00045390637933451217,0.00045299385291636335,0.0004535150021018291,61 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,hitting-time/warm-lookup,2.41063247012311e-08,2.2084490241070968e-10,2.3906056270965668e-08,2.761053589270695e-08,2.400834923811003e-08,2.432013360167845e-08,287 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,hitting/bounded/at-most/k-10,1.4094579010351945e-05,8.641755329554946e-08,1.3995308355682436e-05,1.416628584268987e-05,1.4064709194800228e-05,1.4113669926947101e-05,132 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,hitting/bounded/at-most/k-100,0.00010254249706592285,9.459824029230883e-08,0.00010246878421943014,0.00010269683959733655,0.0001025042840682409,0.00010258092459506014,91 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,hitting/bounded/exact/k-10,1.383851130448868e-05,3.724287107401842e-08,1.3811720106954013e-05,1.3894668924879009e-05,1.383230792726261e-05,1.3848548129881944e-05,132 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,hitting/bounded/exact/k-100,0.0001024263198298679,1.7058325722445298e-07,0.00010227213541370338,0.0001026569428969012,0.0001023828183490507,0.00010247404695948279,91 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,hitting/bounded/greater-than/k-10,1.3966299717294726e-05,3.4944830840086925e-08,1.3932856672312642e-05,1.4003411073511818e-05,1.394891731570638e-05,1.3977776371979025e-05,131 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,hitting/bounded/greater-than/k-100,0.00010290296823337772,1.0749405739502924e-07,0.00010279593980893131,0.00010301256657010272,0.0001028690049203024,0.00010294709335073453,91 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,occupation-matrix,0.003845998793173288,6.273786662206078e-06,0.0038411455356187865,0.0038538213524096725,0.0038426036005078526,0.0038492885253314547,40 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,power/10,0.0001657028052547897,2.3638880871154752e-07,0.00016555642914428014,0.0001663023536481455,0.00016563979706784332,0.00016578774373640924,107 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,power/100,0.00020683594537227856,3.7305154702969737e-07,0.00020650170227730447,0.0002072303793749273,0.00020667793147586047,0.0002069745145826284,102 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,power/2,0.00013338298634913022,1.143691639210367e-07,0.00013329076942011995,0.00013355032048517992,0.0001333346773472224,0.00013343369168627016,111 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,return/bounded/k-10,1.2326919835660096e-05,4.721553390172805e-08,1.2290529201444865e-05,1.2418642122372003e-05,1.2310781333953377e-05,1.234534197612286e-05,134 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,return/bounded/k-100,0.00010092687461257517,9.056736844311494e-08,0.00010085553170871407,0.00010103517550825407,0.00010089588273937503,0.00010096423821302043,91 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,stationary,0.0001629682964823373,4.282972796642269e-07,0.00016252328960915968,0.00016334771146258513,0.00016275679430292843,0.0001631360844140335,81 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,structure/classes-cold,0.00012839201084128201,4.848793989914701e-07,0.00012793559186935293,0.00012902306815877683,0.00012816024644828956,0.00012854197798746594,86 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,structure/classes-lifecycle,0.0009009593334104423,4.579704230227516e-06,0.0008888333633711392,0.0009049498840940414,0.0009002043270111943,0.0009035743001732044,73 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,structure/classes-warm/access,8.61636402155113e-09,1.0510601752022535e-10,8.526660053357289e-09,1.1135058627388943e-08,8.573976604381407e-09,8.681024040674656e-09,309 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,structure/classes-warm/consumed,4.985343414152563e-07,2.5201637656006368e-09,4.964290145039834e-07,5.121015716079774e-07,4.981433074902889e-07,5.0007191282133e-07,226 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,structure/irreducible-cold,0.00012003430860608609,4.3707956625391783e-07,0.00011964422118508496,0.00012069420418728524,0.00011994379679807488,0.00012025913727559047,88 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,structure/irreducible-warm,9.428461997860163e-09,1.1135458716387148e-10,9.333279432019344e-09,1.1854324123409928e-08,9.393276432258627e-09,9.519108165883267e-09,307 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,visits/bounded-expectation/k-10,1.5177976433249647e-05,2.9757071075706044e-08,1.51529053659437e-05,1.522410882663465e-05,1.5168377732128422e-05,1.51851405533912e-05,130 +dtmc,absorbing-n0100-s01729,absorbing,100,1729,visits/bounded-expectation/k-100,0.0001247240983868245,1.4709181531572337e-07,0.00012460786342166508,0.00012490044787523107,0.00012465663176408346,0.00012475957834609395,86 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,absorption-time,0.0006158213300110145,3.868844382500685e-06,0.0006118255795437298,0.0006190482218837935,0.0006132329124904408,0.0006174215311410103,58 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,absorption/probabilities,0.0005020887970443399,3.247924144100605e-06,0.0004985658405517377,0.0005046274487136139,0.000500496185850352,0.0005032249787953474,61 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,construction/public-consumed,0.000585390355186782,6.34821889546229e-07,0.0005847902667786305,0.0005861695967165328,0.0005852291667704574,0.0005856709001818671,81 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,evolution/k-10,1.0144662465081743e-05,2.148281833434832e-08,1.0126951208523957e-05,1.0254252110062419e-05,1.0137378771412572e-05,1.0154982006316504e-05,164 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,evolution/k-100,9.513631771874821e-05,1.4670271665599813e-07,9.503900457310139e-05,9.585309515601308e-05,9.509621851401304e-05,9.517474178698932e-05,118 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,evolution/one-step,1.7499998928262637e-06,8.463903365118457e-08,1.603560973391221e-06,1.8000001243005196e-06,1.738417065805859e-06,1.7658568963053681e-06,201 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,finite-time/n-step/k-10,1.1971190818178567e-05,6.21998905559139e-08,1.1931733306668394e-05,1.2101684353709313e-05,1.1956538082677402e-05,1.2001709688034997e-05,135 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,finite-time/n-step/k-100,9.767299653034244e-05,4.1205067215534377e-07,9.736414955481009e-05,0.00010135075075702523,9.748361364999009e-05,9.828414308110076e-05,92 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,finite-time/observation/k-10,1.449676433740374e-05,4.912438611319773e-08,1.4464192341843766e-05,1.4578718069975864e-05,1.4490596881574567e-05,1.4512865232492638e-05,131 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,finite-time/observation/k-100,0.00010002392938616067,1.1772919236064012e-07,9.990509906156848e-05,0.00010012965166204749,9.997979542540927e-05,0.00010006089901215076,91 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,finite-time/step,8.73181594269533e-07,9.259711197172887e-09,8.652060049604513e-07,8.863865420402539e-07,8.708089244231224e-07,8.760508579175562e-07,187 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,fundamental-matrix,0.0008969764967332594,6.60145787361008e-06,0.0008909929718356579,0.0009041480407951043,0.0008942811869928846,0.0008992593247967307,57 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,hitting-probability/cold-all-states,0.00046147184819722223,7.119071175142966e-07,0.0004606736900034146,0.0004620855118477,0.00046128012141548346,0.00046183914249982934,60 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,hitting-probability/warm-lookup,2.413623902171794e-08,5.112985089411024e-10,2.363601422708573e-08,2.7605475546245963e-08,2.3738198077260927e-08,2.4318504949422344e-08,288 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,hitting-time/cold-all-states,0.00045458963707274686,1.0207709633246892e-06,0.0004538139534270158,0.0004559079737586529,0.00045414405452136536,0.0004553414054008989,60 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,hitting-time/warm-lookup,2.4125366563552146e-08,2.3002466519636812e-10,2.392800593692645e-08,2.7719605946631484e-08,2.402688988232524e-08,2.429595902512335e-08,287 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,hitting/bounded/at-most/k-10,1.3971045551574733e-05,4.1071069164710106e-08,1.3936098172522957e-05,1.4037467771538536e-05,1.3961036888949439e-05,1.398377881506113e-05,131 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,hitting/bounded/at-most/k-100,0.0001100347549337047,6.080257022717782e-06,0.00010436760337779339,0.00012487436345887262,0.00010708706123236498,0.00011179851265440352,90 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,hitting/bounded/exact/k-10,1.3883689579804363e-05,3.657392062371784e-08,1.3864084281700483e-05,1.3945322383993439e-05,1.3875873496835219e-05,1.38997653266415e-05,132 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,hitting/bounded/exact/k-100,0.00010256146559038678,1.1319234144522433e-07,0.00010247130994684995,0.00010277238124017493,0.00010251539545909812,0.0001025899408990812,91 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,hitting/bounded/greater-than/k-10,1.424406715820596e-05,1.951856636736517e-07,1.4099224742146942e-05,1.4598022930897485e-05,1.417517584967671e-05,1.4301725913714053e-05,131 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,hitting/bounded/greater-than/k-100,0.00010371863847980514,9.513587559968725e-07,0.00010297164191451148,0.00011412141192974916,0.0001033409414309614,0.00010560269724506229,88 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,occupation-matrix,0.0038555700042966884,9.377276208916933e-06,0.0038495059715818285,0.003871003131258904,0.0038513779940191084,0.0038639720005448908,39 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,power/10,0.00016534306365120188,2.016712767241417e-07,0.0001652106171020851,0.00016559827095736465,0.00016528185082234466,0.00016543654518582943,107 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,power/100,0.00020709856956576306,9.494222225650643e-07,0.00020623087588286885,0.00020806247985525434,0.0002067391305109081,0.0002073194451181085,102 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,power/2,0.00013310881557612164,1.4085669503810625e-07,0.00013298358126130326,0.00013332390257606415,0.00013307659886080303,0.00013316546371071667,111 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,return/bounded/k-10,1.2494616652363721e-05,1.391481060129239e-07,1.2373536135003502e-05,1.2722448445856571e-05,1.243610585549178e-05,1.2543405028292165e-05,133 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,return/bounded/k-100,0.00010093214184203015,2.0252975131974498e-07,0.00010073846666150223,0.00010116043394973658,0.0001008282570875821,0.00010099928940590061,90 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,stationary,0.00016355088734020353,8.174626176296314e-07,0.00016272434843883204,0.00016421767286374235,0.00016316450055455788,0.00016378094159969777,81 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,structure/classes-cold,0.000128556857706424,4.871883434001044e-07,0.0001282002820662662,0.00012919296811257178,0.00012832565495837797,0.0001287561447584333,86 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,structure/classes-lifecycle,0.0009065042641640713,4.1386938946699823e-05,0.0008882469966920325,0.0009928935781065426,0.0008992006607526205,0.0009378880162970014,70 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,structure/classes-warm/access,8.601519056541628e-09,9.689155329859956e-11,8.519971738425202e-09,1.1135058627388943e-08,8.556331552587222e-09,8.8065592548996e-09,309 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,structure/classes-warm/consumed,4.97374976083093e-07,1.6629940970042094e-09,4.961309739069601e-07,5.1142826052344e-07,4.966335889028655e-07,4.99951867421045e-07,226 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,structure/irreducible-cold,0.00012057728810654278,5.885094164710035e-07,0.00012004111214397234,0.00012116723113414534,0.00012030815008928943,0.00012073144575373994,87 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,structure/irreducible-warm,9.42699788813796e-09,1.1065298913009438e-10,9.329809539771754e-09,1.16978404972418e-08,9.390181242336444e-09,9.548608027721961e-09,307 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,visits/bounded-expectation/k-10,1.525000164595743e-05,1.4969779224906163e-07,1.5145028794833114e-05,1.5698273218180418e-05,1.5195696014081015e-05,1.5322412187732798e-05,129 +dtmc,absorbing-n0100-s02718,absorbing,100,2718,visits/bounded-expectation/k-100,0.0001245423791934391,1.973730158405854e-07,0.0001243939306527765,0.00012482721172596536,0.00012447268125556765,0.00012463648959148524,87 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,absorption-time,0.0006105339447171182,1.8553722551778971e-06,0.0006092977283780662,0.000613485343291402,0.000610020241103343,0.0006120954126612667,59 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,absorption/probabilities,0.0004984842895098246,1.6761550913383608e-06,0.0004973113117739558,0.0005014074461845061,0.0004977506843195963,0.000500160444601163,61 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,construction/public-consumed,0.0005867382133507837,6.971828501165823e-07,0.0005847512423343053,0.0005869437267130107,0.0005865607923882775,0.0005868453389651268,81 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,evolution/k-10,1.0148922905783382e-05,1.1538364918911797e-08,1.014100618582238e-05,1.0187331200451307e-05,1.014686021986392e-05,1.0153176684307282e-05,164 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,evolution/k-100,9.520771153000279e-05,1.0806473315852364e-07,9.516876893369057e-05,9.54459769259715e-05,9.519849941067851e-05,9.521844658946384e-05,118 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,evolution/one-step,1.615027959421076e-06,1.0921053733535723e-08,1.6048759573497221e-06,1.6372803363272658e-06,1.608421936137138e-06,1.6179873675259222e-06,202 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,finite-time/n-step/k-10,1.2548212874823311e-05,1.1242991641709307e-07,1.2446784668276883e-05,1.266092471826671e-05,1.2512224517028597e-05,1.2580336124520932e-05,134 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,finite-time/n-step/k-100,9.705352098939734e-05,2.774777199062605e-07,9.6856035364563e-05,9.773509412233745e-05,9.694451256268233e-05,9.740048140147802e-05,92 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,finite-time/observation/k-10,1.5225996433662196e-05,1.9110995443309987e-07,1.5001849923074978e-05,1.5376188303364258e-05,1.5137834956711544e-05,1.5264774035341608e-05,130 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,finite-time/observation/k-100,0.00010024369670371589,2.1653808015462378e-07,0.00010002482523550354,0.00010040709435592233,0.00010019436731339209,0.00010031028622983112,91 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,finite-time/step,9.001513123071344e-07,1.1773884526889287e-08,8.908819529539295e-07,9.239549454517823e-07,8.961605205896655e-07,9.025894678629577e-07,184 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,fundamental-matrix,0.0008870539301419396,2.9540657904045904e-06,0.000884099864351535,0.0008899962662954081,0.0008854957752414428,0.0008884504986781394,57 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,hitting-probability/cold-all-states,0.000460511815041143,5.796595274923616e-07,0.0004599758654949255,0.0004611357606374536,0.0004602882160855058,0.00046081264112477323,60 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,hitting-probability/warm-lookup,2.4009795566311133e-08,4.065166051789312e-10,2.3613583638145267e-08,2.7635757669433735e-08,2.37226846831177e-08,2.4329983259565267e-08,288 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,hitting-time/cold-all-states,0.0004531378550122359,5.804882717451638e-07,0.000452589750195676,0.0004537183432839811,0.0004527292850460591,0.0004533716538037192,61 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,hitting-time/warm-lookup,2.4017481252615414e-08,1.5076410750962378e-10,2.3889570963145183e-08,2.7151923680079427e-08,2.395529883211892e-08,2.414874975855027e-08,288 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,hitting/bounded/at-most/k-10,1.4867009919750078e-05,1.7004445350832338e-07,1.4646050763794367e-05,1.4988858279006092e-05,1.4809410211562343e-05,1.4917919271419511e-05,130 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,hitting/bounded/at-most/k-100,0.00010325112842630395,2.029252799511241e-07,0.00010304246878139824,0.00010344522604032656,0.00010315516075659719,0.00010331822663231317,91 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,hitting/bounded/exact/k-10,1.451483509854524e-05,9.848018981767904e-08,1.4382639930552834e-05,1.4594552759176941e-05,1.4491871325779207e-05,1.4537765113404131e-05,131 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,hitting/bounded/exact/k-100,0.00010308319057833727,2.4503089780877495e-07,0.00010284195116702279,0.0001033369442004848,0.00010301200174061316,0.00010320832370780408,91 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,hitting/bounded/greater-than/k-10,1.4703085565367552e-05,2.2970972002264056e-07,1.4005125801001366e-05,1.4882604705569337e-05,1.4627130197671552e-05,1.4755658786233566e-05,131 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,hitting/bounded/greater-than/k-100,0.00010361071015736586,1.821586311109792e-07,0.00010333596509931546,0.0001037797304689613,0.00010354460351334372,0.00010366667023239036,91 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,occupation-matrix,0.003837865569059634,5.701715520564556e-06,0.0038325691614113687,0.003845143642428121,0.003833174690953456,0.0038413752793400946,40 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,power/10,0.000165661355890288,1.3617195919295166e-07,0.00016557313472255394,0.00016585959008093244,0.00016563657387720282,0.00016571463784202932,107 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,power/100,0.00020663387490823035,3.812837161261493e-07,0.00020624349153652087,0.00020701314660982463,0.0002064675920982413,0.0002067655418708844,102 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,power/2,0.00013322093429068396,6.291997102934248e-08,0.00013318408658094446,0.00013346475953137716,0.00013320615033394305,0.00013324248013942884,111 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,return/bounded/k-10,1.3241750063267924e-05,1.5247971345954101e-07,1.3129562777917712e-05,1.340569756196245e-05,1.3185586471515269e-05,1.328065135406659e-05,133 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,return/bounded/k-100,0.00010161829132196163,5.310385829708963e-07,0.00010050446660407321,0.00010196064179696203,0.0001014358024160221,0.00010182162016902245,91 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,stationary,0.00016253138773561436,5.055984833103101e-07,0.0001620196460006649,0.00016297807451337576,0.00016242957278675822,0.00016273506874981593,81 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,structure/classes-cold,0.00012850535829722948,6.586011520807441e-07,0.00012805413558093933,0.0001297588216475782,0.00012820805913131488,0.00012886133609990778,86 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,structure/classes-lifecycle,0.000898417778749975,7.127540730961744e-06,0.0008843026313881733,0.0009039987273740046,0.0008965262003974723,0.0009007193025593695,73 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,structure/classes-warm/access,8.622128589326345e-09,1.3410920632995975e-10,8.503392482992271e-09,1.130080636162875e-08,8.550798888644725e-09,8.736191365560685e-09,308 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,structure/classes-warm/consumed,4.963777756030005e-07,1.3095413536189235e-09,4.954043442722056e-07,5.129212599679123e-07,4.959665730752995e-07,4.971401900619122e-07,226 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,structure/irreducible-cold,0.00012019657047598489,5.860531619416432e-07,0.00011964058873530718,0.00012087212490775932,0.00011992825302607428,0.00012053338253860024,87 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,structure/irreducible-warm,9.385293922821058e-09,8.461607535040203e-11,9.314767813880641e-09,1.176536704667414e-08,9.340881447562107e-09,9.464973421664743e-09,307 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,visits/bounded-expectation/k-10,1.6082788964635447e-05,1.9920306722459835e-07,1.5875667752417084e-05,1.626507028664261e-05,1.6029621148046767e-05,1.6119350550760484e-05,127 +dtmc,absorbing-n0100-s31415,absorbing,100,31415,visits/bounded-expectation/k-100,0.00012453580813442347,1.3225064165415124e-07,0.00012441083530305788,0.00012468324437657578,0.00012448113358748907,0.00012456444366964407,87 +dtmc,absorbing-n0250-s01729,absorbing,250,1729,absorption-time,0.0047971667206313994,5.408664151468432e-05,0.004747855463453258,0.0048801388329593465,0.004756454547697847,0.004878810996440454,25 +dtmc,absorbing-n0250-s01729,absorbing,250,1729,absorption/probabilities,0.0029601486926284534,1.0238608758134484e-05,0.0029505154669591735,0.002979067627165932,0.002952143607433841,0.002969879978539902,28 +dtmc,absorbing-n0250-s01729,absorbing,250,1729,construction/public-consumed,0.005177602494562355,4.3006965199657125e-05,0.005125008337563486,0.005213048513195967,0.005151970633346584,0.005198127687292168,40 +dtmc,absorbing-n0250-s01729,absorbing,250,1729,evolution/k-10,7.573978224078152e-05,7.03158781362878e-08,7.56784457194241e-05,7.583919572285734e-05,7.57256635110042e-05,7.575198386301546e-05,123 +dtmc,absorbing-n0250-s01729,absorbing,250,1729,evolution/k-100,0.0007432205990196227,4.88383809766344e-07,0.0007429953916674299,0.0007440779002406218,0.000743145124943112,0.0007434566496387213,76 +dtmc,absorbing-n0250-s01729,absorbing,250,1729,evolution/one-step,9.069562558526622e-06,1.5278455190147007e-08,9.05839113907036e-06,9.143606973461378e-06,9.065199590626579e-06,9.077535323974153e-06,166 +dtmc,absorbing-n0250-s01729,absorbing,250,1729,fundamental-matrix,0.0058843325156929145,3.9143401564291965e-05,0.005846869496060261,0.0059238630595315886,0.005856422711596159,0.00590846038317573,24 +dtmc,absorbing-n0250-s01729,absorbing,250,1729,hitting-probability/cold-all-states,0.004032688061670342,6.330729775072541e-06,0.004027450514100068,0.004041926934359704,0.004030058736033324,0.004037847647551745,26 +dtmc,absorbing-n0250-s01729,absorbing,250,1729,hitting-probability/warm-lookup,2.378814972483478e-08,1.8101587725192455e-10,2.3695092793658858e-08,2.7149171216998564e-08,2.3763513520886816e-08,2.3891087810100345e-08,288 +dtmc,absorbing-n0250-s01729,absorbing,250,1729,hitting-time/cold-all-states,0.004045310000138771,1.1632749293413042e-05,0.004038882498703474,0.004061784917818538,0.004039382346926014,0.0040565591035900935,25 +dtmc,absorbing-n0250-s01729,absorbing,250,1729,hitting-time/warm-lookup,2.4123155197054175e-08,2.733703140449585e-10,2.3868651726261314e-08,2.7224518567231577e-08,2.3999607967139106e-08,2.4320140462553145e-08,288 +dtmc,absorbing-n0250-s01729,absorbing,250,1729,occupation-matrix,0.03500836942839669,0.0015379752202444343,0.03349875117133447,0.037207837053886444,0.033524588696829075,0.037214067746390356,14 +dtmc,absorbing-n0250-s01729,absorbing,250,1729,power/10,0.0011376341204790657,1.4144148189145639e-05,0.00112090285862602,0.0011479150127600983,0.0011291512473924055,0.0011426828021094003,68 +dtmc,absorbing-n0250-s01729,absorbing,250,1729,power/100,0.0015975181304384023,1.939993665725807e-05,0.0015789571426077082,0.0016169180670956604,0.001586966699687764,0.0016021743266515396,61 +dtmc,absorbing-n0250-s01729,absorbing,250,1729,power/2,0.0008133676591652064,1.131566287685098e-05,0.000796497596638801,0.0008196238872364421,0.0008043193277747681,0.0008154463177577064,75 +dtmc,absorbing-n0250-s01729,absorbing,250,1729,stationary,0.001075968716274171,1.0957974558954827e-05,0.0010633539465284892,0.0010856936060397683,0.0010670926615906258,0.0010809879292667443,43 +dtmc,absorbing-n0250-s01729,absorbing,250,1729,structure/classes-cold,0.0008577487980281669,6.8560835816675915e-06,0.000853204986277467,0.0008688295990731077,0.0008544098333610842,0.0008644195091747271,47 +dtmc,absorbing-n0250-s01729,absorbing,250,1729,structure/classes-lifecycle,0.00822144318160347,3.349851824830004e-05,0.008195097826461753,0.00825494169985177,0.00820165044569876,0.008245018939664023,33 +dtmc,absorbing-n0250-s01729,absorbing,250,1729,structure/classes-warm/access,8.930234320849497e-09,4.0680078800503504e-10,8.527297301653433e-09,1.1014378089029557e-08,8.820389894541567e-09,9.042907157677645e-09,309 +dtmc,absorbing-n0250-s01729,absorbing,250,1729,structure/classes-warm/consumed,1.2638497014621889e-06,3.0472572190196583e-09,1.261791038596148e-06,1.2747912348588995e-06,1.2627305724163592e-06,1.2660676218804905e-06,206 +dtmc,absorbing-n0250-s01729,absorbing,250,1729,structure/irreducible-cold,0.0008440340017458718,8.271673179574709e-06,0.0008361873463214305,0.0008527581202016384,0.0008397448000323493,0.0008491875050822273,47 +dtmc,absorbing-n0250-s01729,absorbing,250,1729,structure/irreducible-warm,9.366331111798531e-09,8.143485667885282e-11,9.299965154465404e-09,1.1766901134122913e-08,9.335259922272686e-09,9.459181785056455e-09,307 +dtmc,absorbing-n0250-s02718,absorbing,250,2718,absorption-time,0.004723573827835604,2.1964587473666253e-05,0.004717301289771137,0.004766827910869182,0.0047181706662134575,0.0047411348236731585,26 +dtmc,absorbing-n0250-s02718,absorbing,250,2718,absorption/probabilities,0.0029492332638862235,4.808974853788865e-06,0.002943008237707545,0.0029514208206795826,0.002943514340679543,0.002950902149915118,28 +dtmc,absorbing-n0250-s02718,absorbing,250,2718,construction/public-consumed,0.005168784991058471,3.191870105351659e-05,0.005120144104391026,0.005193553788902998,0.005137966822506937,0.00518789294909328,40 +dtmc,absorbing-n0250-s02718,absorbing,250,2718,evolution/k-10,7.578858949660145e-05,6.51167938621049e-08,7.574959329451501e-05,7.593139554306324e-05,7.576787485738277e-05,7.580842376007018e-05,123 +dtmc,absorbing-n0250-s02718,absorbing,250,2718,evolution/k-100,0.0007428595163347931,5.713220829599579e-07,0.000742458482149369,0.0007440992217309338,0.0007427104879986755,0.0007431536250805948,76 +dtmc,absorbing-n0250-s02718,absorbing,250,2718,evolution/one-step,9.056195273582375e-06,1.3149781408644251e-08,9.049260668064656e-06,9.108764953079575e-06,9.05400042531427e-06,9.066212107044474e-06,166 +dtmc,absorbing-n0250-s02718,absorbing,250,2718,fundamental-matrix,0.005837848122396013,1.9172125867281467e-05,0.005821654714444386,0.005862104397965595,0.005823364623211091,0.005857576768343838,25 +dtmc,absorbing-n0250-s02718,absorbing,250,2718,hitting-probability/cold-all-states,0.0040331654337933285,8.830693563637113e-06,0.00402738119926114,0.004045628439457614,0.004029192728425928,0.0040403554607606074,26 +dtmc,absorbing-n0250-s02718,absorbing,250,2718,hitting-probability/warm-lookup,2.3763158243545176e-08,1.8056931235799575e-10,2.362416968332701e-08,2.7432650717148613e-08,2.368348047170555e-08,2.3992501130917993e-08,288 +dtmc,absorbing-n0250-s02718,absorbing,250,2718,hitting-time/cold-all-states,0.004030618144315668,8.197338320315058e-06,0.0040225541262771,0.0040386800051476855,0.004023817255438189,0.004035664694674779,26 +dtmc,absorbing-n0250-s02718,absorbing,250,2718,hitting-time/warm-lookup,2.4053975156509884e-08,2.0617552045007694e-10,2.3879830280409895e-08,2.753004096505877e-08,2.395012181903974e-08,2.4244589699075807e-08,288 +dtmc,absorbing-n0250-s02718,absorbing,250,2718,occupation-matrix,0.03333576113024416,2.473525407064442e-05,0.03331438622929757,0.033388373971522216,0.03331102587617352,0.03335879643822813,15 +dtmc,absorbing-n0250-s02718,absorbing,250,2718,power/10,0.0011392187964523542,1.5208731613601143e-05,0.001120859551508235,0.0011491969057024108,0.0011280184292282239,0.001144109375002843,68 +dtmc,absorbing-n0250-s02718,absorbing,250,2718,power/100,0.001597195015523484,1.6868625715034976e-05,0.0015756269886835418,0.0016106045735440624,0.001589067796980365,0.0016034832930361038,62 +dtmc,absorbing-n0250-s02718,absorbing,250,2718,power/2,0.000811957901964185,1.4073287076752533e-05,0.00079546066586368,0.0008196965748907168,0.0008072016564311588,0.0008153068517103902,75 +dtmc,absorbing-n0250-s02718,absorbing,250,2718,stationary,0.001064083495293744,8.492497727274895e-06,0.0010583361395777413,0.0010877588938456029,0.00106031086364634,0.0010735256122037147,43 +dtmc,absorbing-n0250-s02718,absorbing,250,2718,structure/classes-cold,0.0008669315336322013,9.48993145443854e-06,0.0008611448012578132,0.0008794185977689374,0.0008643109982725806,0.0008750231055800166,47 +dtmc,absorbing-n0250-s02718,absorbing,250,2718,structure/classes-lifecycle,0.008214704333416497,3.118108240111363e-05,0.008191741935368027,0.008262693180850792,0.008202841656748205,0.008243477050564251,33 +dtmc,absorbing-n0250-s02718,absorbing,250,2718,structure/classes-warm/access,8.609630174270288e-09,1.2480578478992905e-10,8.499770713522128e-09,1.0918670176831355e-08,8.575738601146495e-09,8.662348471807154e-09,309 +dtmc,absorbing-n0250-s02718,absorbing,250,2718,structure/classes-warm/consumed,1.2652655471736772e-06,5.175705913992313e-09,1.2602358963927425e-06,1.2716047898264339e-06,1.2636953463676963e-06,1.2662163751044214e-06,206 +dtmc,absorbing-n0250-s02718,absorbing,250,2718,structure/irreducible-cold,0.0008361522545877968,8.052118794754073e-06,0.0008305065731708168,0.0008462163714284543,0.0008324260907193818,0.0008441512510240173,48 +dtmc,absorbing-n0250-s02718,absorbing,250,2718,structure/irreducible-warm,9.401092654136757e-09,1.1047425815631066e-10,9.30248470939267e-09,1.1766260427574656e-08,9.335599404022605e-09,9.491790666417178e-09,307 +dtmc,absorbing-n0250-s31415,absorbing,250,31415,absorption-time,0.004796393129610173,2.6132417651964987e-05,0.004787794329846899,0.004842374997679144,0.004790472162615818,0.004828220000490546,25 +dtmc,absorbing-n0250-s31415,absorbing,250,31415,absorption/probabilities,0.0030360233342637205,3.445663735167012e-05,0.003004836210969924,0.003148961098243793,0.003013098739565497,0.0030982085008872673,27 +dtmc,absorbing-n0250-s31415,absorbing,250,31415,construction/public-consumed,0.005189685520290919,3.7842558818030215e-05,0.0051461632658332665,0.005217008571509557,0.005171234739094213,0.005207796307975495,40 +dtmc,absorbing-n0250-s31415,absorbing,250,31415,evolution/k-10,7.589180693850557e-05,9.626036289402573e-08,7.582867706068531e-05,7.614428974730717e-05,7.587159748054432e-05,7.592451457521352e-05,123 +dtmc,absorbing-n0250-s31415,absorbing,250,31415,evolution/k-100,0.0007432166859116106,3.2876530130877607e-07,0.000742998235468154,0.0007440166239414156,0.0007431309464404226,0.0007433946473825284,76 +dtmc,absorbing-n0250-s31415,absorbing,250,31415,evolution/one-step,9.07865750826541e-06,2.852062318967077e-08,9.053991568206828e-06,9.172679838698262e-06,9.064678860777488e-06,9.089285629757104e-06,166 +dtmc,absorbing-n0250-s31415,absorbing,250,31415,fundamental-matrix,0.0061285316658627595,5.981390824585844e-05,0.006081585200744859,0.006295443786906877,0.0060906770631845575,0.006182655997690745,23 +dtmc,absorbing-n0250-s31415,absorbing,250,31415,hitting-probability/cold-all-states,0.004121619075885974,5.906039158227409e-05,0.00406614454453423,0.0041859226459083024,0.00407302539194158,0.004158583624201937,26 +dtmc,absorbing-n0250-s31415,absorbing,250,31415,hitting-probability/warm-lookup,2.448731935012791e-08,8.527614135002571e-10,2.3821955009050963e-08,2.858095366612085e-08,2.4242067264826156e-08,2.495335265189866e-08,287 +dtmc,absorbing-n0250-s31415,absorbing,250,31415,hitting-time/cold-all-states,0.004153147759145787,4.264179297024367e-05,0.00410192725151622,0.004180570619999864,0.004110258197761141,0.004171030531110268,26 +dtmc,absorbing-n0250-s31415,absorbing,250,31415,hitting-time/warm-lookup,2.468558990458921e-08,7.998741365589496e-10,2.3937347646947767e-08,2.8382313125482286e-08,2.4285487344644546e-08,2.528027711474671e-08,287 +dtmc,absorbing-n0250-s31415,absorbing,250,31415,occupation-matrix,0.0360833257145714,0.002438564192319366,0.03362689638415759,0.037611883324279914,0.03361151862627594,0.037644986169956006,14 +dtmc,absorbing-n0250-s31415,absorbing,250,31415,power/10,0.0011400424618845783,1.294729532423872e-05,0.0011225896261748858,0.0011494551937460647,0.0011292532121481757,0.0011445984579971733,68 +dtmc,absorbing-n0250-s31415,absorbing,250,31415,power/100,0.0015958443813073437,1.6865624881271858e-05,0.0015781993875602243,0.0016111927685328984,0.0015824762148050858,0.0016035427631179214,62 +dtmc,absorbing-n0250-s31415,absorbing,250,31415,power/2,0.0008149157305054492,1.2868620314501885e-05,0.0007975343272901364,0.0008204364484821905,0.0008104162870613099,0.0008169417807749435,75 +dtmc,absorbing-n0250-s31415,absorbing,250,31415,stationary,0.0010912812176684383,1.677016622298182e-05,0.0010825118613748573,0.0011193906830158085,0.0010856809292305023,0.0011065644534288108,42 +dtmc,absorbing-n0250-s31415,absorbing,250,31415,structure/classes-cold,0.0008684617024630123,9.447111660290707e-06,0.0008621773655509709,0.0008867461844917615,0.0008658327631647726,0.0008780879255937179,42 +dtmc,absorbing-n0250-s31415,absorbing,250,31415,structure/classes-lifecycle,0.008255721591095526,4.4140068739616234e-05,0.008218902000568478,0.008302795454669236,0.00823571628591578,0.008282689815300896,33 +dtmc,absorbing-n0250-s31415,absorbing,250,31415,structure/classes-warm/access,9.197454929061324e-09,6.41602399049126e-10,8.601543946958155e-09,1.1734974646059138e-08,9.087928473819044e-09,9.347667473642362e-09,308 +dtmc,absorbing-n0250-s31415,absorbing,250,31415,structure/classes-warm/consumed,1.3351450315534453e-06,2.256611325976648e-08,1.3034294083637408e-06,1.3478489549787342e-06,1.3325211552597436e-06,1.338113814387584e-06,206 +dtmc,absorbing-n0250-s31415,absorbing,250,31415,structure/irreducible-cold,0.0008568935971855721,1.1211714525165934e-05,0.0008475313285695544,0.0008746796699273538,0.0008504630003935071,0.0008677552999870386,47 +dtmc,absorbing-n0250-s31415,absorbing,250,31415,structure/irreducible-warm,9.457895609222228e-09,1.5158744484893323e-10,9.3321243487635e-09,1.2021586301096682e-08,9.41701809167546e-09,9.535291842842997e-09,307 +dtmc,absorbing-n0500-s01729,absorbing,500,1729,absorption-time,0.032841548474971206,0.0012812605054932646,0.031434744817589594,0.033752698047464946,0.03125718749652151,0.03512320832669502,10 +dtmc,absorbing-n0500-s01729,absorbing,500,1729,absorption/probabilities,0.023222287349926773,0.00027035616876673954,0.023106132552129566,0.023575118961161934,0.023068702979799127,0.023637273639906198,12 +dtmc,absorbing-n0500-s01729,absorbing,500,1729,construction/public-consumed,0.030709381914978927,0.0013689726355633793,0.029433727245150997,0.03267152800117401,0.029443522460776597,0.03264228763592572,16 +dtmc,absorbing-n0500-s01729,absorbing,500,1729,evolution/k-10,0.0002983999557576074,9.988335326245883e-07,0.00029745499510421984,0.00029945622931340445,0.0002980800897990002,0.0002987298385931119,95 +dtmc,absorbing-n0500-s01729,absorbing,500,1729,evolution/k-100,0.0029555526394815707,6.022690714042444e-06,0.00295122614303802,0.002980579140181662,0.002952908876150931,0.0029684101954928765,50 +dtmc,absorbing-n0500-s01729,absorbing,500,1729,evolution/one-step,3.284974535350412e-05,8.643240215037306e-08,3.2786090381689974e-05,3.299820968886747e-05,3.282835001158816e-05,3.2869467728318295e-05,140 +dtmc,absorbing-n0500-s01729,absorbing,500,1729,fundamental-matrix,0.030463652767139138,0.0007006591258686967,0.03010837120382348,0.031243187934402766,0.029871661128709093,0.033339246239241525,10 +dtmc,absorbing-n0500-s01729,absorbing,500,1729,hitting-probability/cold-all-states,0.029355072751059197,0.0006042548431485738,0.0289930514279279,0.0307999895788574,0.028827529862090678,0.031292235992926486,11 +dtmc,absorbing-n0500-s01729,absorbing,500,1729,hitting-probability/warm-lookup,2.391491250956277e-08,3.0811331086992573e-10,2.3629817603343466e-08,2.7249580610158265e-08,2.3757828120905018e-08,2.4073702626003116e-08,288 +dtmc,absorbing-n0500-s01729,absorbing,500,1729,hitting-time/cold-all-states,0.02876624475538847,0.000526027850719403,0.028401992860943373,0.029169687435043872,0.028240216904669067,0.029441333207068966,11 +dtmc,absorbing-n0500-s01729,absorbing,500,1729,hitting-time/warm-lookup,2.4254955147019886e-08,3.7881190043835366e-10,2.3940317646729636e-08,2.735908598356117e-08,2.4146212412327312e-08,2.4532954347028665e-08,288 +dtmc,absorbing-n0500-s01729,absorbing,500,1729,power/10,0.00667779401627068,7.889520648822522e-05,0.006599053571681864,0.006758641668966447,0.006638381567265076,0.006717829943538943,36 +dtmc,absorbing-n0500-s01729,absorbing,500,1729,power/100,0.011111213114837972,0.00010175012112373892,0.011017016597907058,0.011231756249617319,0.01105877777768506,0.011175999999977648,29 +dtmc,absorbing-n0500-s01729,absorbing,500,1729,power/2,0.004193368232539059,7.397874344841279e-05,0.00410601622206741,0.004257560515781029,0.004142206429302556,0.004220989026515254,44 +dtmc,absorbing-n0500-s01729,absorbing,500,1729,stationary,0.008418122723621007,0.0003603331997786008,0.008293119753943756,0.00945235553704801,0.00827009350177832,0.00978022507513829,12 +dtmc,absorbing-n0500-s01729,absorbing,500,1729,structure/classes-cold,0.007643256405814706,0.00041291905605855047,0.00740181561515342,0.009662340195670064,0.007386594227305849,0.009707972132067273,12 +dtmc,absorbing-n0500-s01729,absorbing,500,1729,structure/classes-lifecycle,0.048783383396221326,0.0002782451037395134,0.04850850466755219,0.04906162849996084,0.04850850466755219,0.04906162849996084,13 +dtmc,absorbing-n0500-s01729,absorbing,500,1729,structure/classes-warm/access,9.063736583180662e-09,3.6831578578352323e-10,8.877477999058638e-09,1.175243630638144e-08,8.99339991150334e-09,9.23566662448004e-09,308 +dtmc,absorbing-n0500-s01729,absorbing,500,1729,structure/classes-warm/consumed,2.5426962083554472e-06,4.821117331526143e-09,2.5395736345814124e-06,2.5597817624404505e-06,2.5418031257133764e-06,2.545454525247668e-06,192 +dtmc,absorbing-n0500-s01729,absorbing,500,1729,structure/irreducible-cold,0.006952374838874675,0.00011548128127793038,0.006855881145124191,0.007196040998678654,0.006855881145124191,0.007196040998678654,13 +dtmc,absorbing-n0500-s01729,absorbing,500,1729,structure/irreducible-warm,9.468361113645625e-09,1.514246543344228e-10,9.328622937173542e-09,1.2195113403819995e-08,9.406338268513395e-09,9.561209531832991e-09,305 +dtmc,absorbing-n0500-s02718,absorbing,500,2718,absorption-time,0.03137921055094921,0.0003607420852252581,0.03127569420757936,0.031852310752583435,0.030928643387077112,0.03199150466631787,10 +dtmc,absorbing-n0500-s02718,absorbing,500,2718,absorption/probabilities,0.02495405532924148,0.0010779363233485231,0.024059452584796498,0.03201660957032194,0.02397562499390915,0.03753394433685268,11 +dtmc,absorbing-n0500-s02718,absorbing,500,2718,construction/public-consumed,0.028316019820877385,0.00026551376360295365,0.02807879379281822,0.028571585904501262,0.028130319328435387,0.02854684547855868,18 +dtmc,absorbing-n0500-s02718,absorbing,500,2718,evolution/k-10,0.0002980072395471127,1.1781796770678557e-06,0.0002971152837354956,0.00029977830259739614,0.0002974840601405563,0.0002984617570530305,94 +dtmc,absorbing-n0500-s02718,absorbing,500,2718,evolution/k-100,0.0029727250007757296,2.308592292814488e-05,0.002947946428321302,0.0029885522453696467,0.002952486110896441,0.0029814917012117802,49 +dtmc,absorbing-n0500-s02718,absorbing,500,2718,evolution/one-step,3.279895285400904e-05,2.6217149086638037e-08,3.278034387408428e-05,3.2852790006828676e-05,3.279179219978424e-05,3.280938111212995e-05,140 +dtmc,absorbing-n0500-s02718,absorbing,500,2718,fundamental-matrix,0.03032728808385501,0.00042700120902736637,0.029897651209726712,0.030637337594816925,0.029806114376697224,0.030730029146070592,10 +dtmc,absorbing-n0500-s02718,absorbing,500,2718,hitting-probability/cold-all-states,0.02898369643038937,0.0004367589335223382,0.028620927154869687,0.029490217063357704,0.02854693749686703,0.029573325003730132,11 +dtmc,absorbing-n0500-s02718,absorbing,500,2718,hitting-probability/warm-lookup,2.3824745491552236e-08,2.2325125431134602e-10,2.362078022045859e-08,2.7201350625346974e-08,2.373860898834662e-08,2.398541723296291e-08,288 +dtmc,absorbing-n0500-s02718,absorbing,500,2718,hitting-time/cold-all-states,0.02875803674760391,0.0005286950508889277,0.028365721982977862,0.029202933158376253,0.028229341696714982,0.02938128320383839,11 +dtmc,absorbing-n0500-s02718,absorbing,500,2718,hitting-time/warm-lookup,2.4099246503902513e-08,2.1887345255743933e-10,2.389652776972242e-08,2.7512701147260083e-08,2.404267625498689e-08,2.4259517203165347e-08,288 +dtmc,absorbing-n0500-s02718,absorbing,500,2718,power/10,0.006609671656458106,8.73927141099573e-05,0.006561114055777816,0.006726758681214137,0.006592034222598563,0.0066611800969938835,36 +dtmc,absorbing-n0500-s02718,absorbing,500,2718,power/100,0.010938876400662897,9.61081489852713e-05,0.010864556817316705,0.011048820850555785,0.01091593749983336,0.011041232143595283,29 +dtmc,absorbing-n0500-s02718,absorbing,500,2718,power/2,0.004289395874366164,0.00015861622241866453,0.004172714970847761,0.00457748826050771,0.004228168841923195,0.004373969890164315,43 +dtmc,absorbing-n0500-s02718,absorbing,500,2718,stationary,0.007795152661856264,8.864242166358414e-05,0.0077070350749776344,0.007883795083519848,0.0077070350749776344,0.007883795083519848,13 +dtmc,absorbing-n0500-s02718,absorbing,500,2718,structure/classes-cold,0.006449511998133468,5.151182579408824e-05,0.00639800017233938,0.006492600098135881,0.00639800017233938,0.006492600098135881,13 +dtmc,absorbing-n0500-s02718,absorbing,500,2718,structure/classes-lifecycle,0.04746588636242615,0.00038555311237525175,0.04696079162749811,0.047789650615483806,0.04696079162749811,0.047789650615483806,13 +dtmc,absorbing-n0500-s02718,absorbing,500,2718,structure/classes-warm/access,8.588343842197829e-09,9.897322974391133e-11,8.503404742998316e-09,1.1052860384588257e-08,8.547770079794551e-09,8.690247425410624e-09,308 +dtmc,absorbing-n0500-s02718,absorbing,500,2718,structure/classes-warm/consumed,2.629386105445323e-06,5.226776019196038e-08,2.580567324679892e-06,2.6839368765548076e-06,2.6108091841712132e-06,2.6470354054444164e-06,192 +dtmc,absorbing-n0500-s02718,absorbing,500,2718,structure/irreducible-cold,0.006925236327030386,0.000160166823964877,0.00680254100007005,0.007119098455983807,0.00680254100007005,0.007119098455983807,13 +dtmc,absorbing-n0500-s02718,absorbing,500,2718,structure/irreducible-warm,9.427956878977181e-09,1.1710402286351405e-10,9.332982912128213e-09,1.1951950500188593e-08,9.386331716996094e-09,9.587704252475406e-09,307 +dtmc,absorbing-n0500-s31415,absorbing,500,31415,absorption-time,0.031515800302440763,0.000720501201327094,0.031225158912396488,0.03250470351777039,0.031183886089950517,0.03258489355600128,10 +dtmc,absorbing-n0500-s31415,absorbing,500,31415,absorption/probabilities,0.023986023082721256,0.00048421107963400253,0.023728569257946218,0.025169682974592433,0.023664222538354807,0.02521516820343095,12 +dtmc,absorbing-n0500-s31415,absorbing,500,31415,construction/public-consumed,0.028707266482645842,0.0001798575556474849,0.028581370888469605,0.02899407594668446,0.028586676277636943,0.028924826566776567,18 +dtmc,absorbing-n0500-s31415,absorbing,500,31415,evolution/k-10,0.00029821225367756426,4.086609214628222e-07,0.0002975787154153093,0.00029848344555688327,0.0002979447347069235,0.00029831111846079575,95 +dtmc,absorbing-n0500-s31415,absorbing,500,31415,evolution/k-100,0.002947376983051765,1.7000655808496572e-06,0.002945953225224955,0.002949356274691793,0.0029467215169764437,0.0029480489894204752,50 +dtmc,absorbing-n0500-s31415,absorbing,500,31415,evolution/one-step,3.282199311182486e-05,1.8906868691234653e-08,3.280920434269525e-05,3.286304915765493e-05,3.281802031667713e-05,3.282601384625002e-05,140 +dtmc,absorbing-n0500-s31415,absorbing,500,31415,fundamental-matrix,0.03187076541944407,0.0012285485815179218,0.03073438947012619,0.033100334948228144,0.03051210985383174,0.033720426817169594,10 +dtmc,absorbing-n0500-s31415,absorbing,500,31415,hitting-probability/cold-all-states,0.028822270745877177,0.0005569124536123141,0.02835780190203381,0.02920170872421295,0.0281717779871542,0.02937918319948949,11 +dtmc,absorbing-n0500-s31415,absorbing,500,31415,hitting-probability/warm-lookup,2.439751570974715e-08,7.664341137045194e-10,2.3697204042989452e-08,2.920530757400008e-08,2.4107499093618183e-08,2.491798301716495e-08,287 +dtmc,absorbing-n0500-s31415,absorbing,500,31415,hitting-time/cold-all-states,0.03334206096068166,0.00233989566428742,0.030898767105827573,0.03535839600226609,0.03077118743670225,0.03630309375512297,10 +dtmc,absorbing-n0500-s31415,absorbing,500,31415,hitting-time/warm-lookup,2.453553840705171e-08,6.297137200454245e-10,2.398781819526545e-08,2.8231073307644888e-08,2.4242643530492373e-08,2.4795165286782877e-08,286 +dtmc,absorbing-n0500-s31415,absorbing,500,31415,power/10,0.006767994466160113,0.00020607782979354707,0.006651305575225572,0.007271453692450641,0.006672160105632716,0.007015174999833107,35 +dtmc,absorbing-n0500-s31415,absorbing,500,31415,power/100,0.011022868083576517,8.206808289590653e-05,0.01096877194695959,0.011135794642281585,0.010974247721605934,0.011093862500274554,29 +dtmc,absorbing-n0500-s31415,absorbing,500,31415,power/2,0.004144938810895837,6.666453362355693e-05,0.004082885118300005,0.004217193857420213,0.004107134149326341,0.004176350031614228,44 +dtmc,absorbing-n0500-s31415,absorbing,500,31415,stationary,0.007730671750323381,7.936165347928199e-05,0.007696215247657771,0.007840292004402727,0.007696215247657771,0.007840292004402727,13 +dtmc,absorbing-n0500-s31415,absorbing,500,31415,structure/classes-cold,0.00670925754820928,7.267756154760718e-05,0.006626179614193881,0.00674970311956713,0.006626179614193881,0.00674970311956713,13 +dtmc,absorbing-n0500-s31415,absorbing,500,31415,structure/classes-lifecycle,0.047993737154264145,0.0004957511533015893,0.047497986000962555,0.04842838749755174,0.047497986000962555,0.04842838749755174,13 +dtmc,absorbing-n0500-s31415,absorbing,500,31415,structure/classes-warm/access,8.601057038788835e-09,9.206552648843199e-11,8.518993373014208e-09,1.1014378089029557e-08,8.566018043218274e-09,8.681225256235542e-09,309 +dtmc,absorbing-n0500-s31415,absorbing,500,31415,structure/classes-warm/consumed,2.543628935454691e-06,3.5612292809078078e-09,2.5413474572781057e-06,2.551851719040046e-06,2.54296525378853e-06,2.544933198123717e-06,192 +dtmc,absorbing-n0500-s31415,absorbing,500,31415,structure/irreducible-cold,0.006880093826718318,2.91433247277895e-05,0.006868342445361325,0.00694535399088636,0.006868342445361325,0.00694535399088636,13 +dtmc,absorbing-n0500-s31415,absorbing,500,31415,structure/irreducible-warm,9.413601134855845e-09,1.0300104440893123e-10,9.327729355924375e-09,1.2008659910808892e-08,9.379167732615913e-09,9.511637452279702e-09,307 +dtmc,absorbing-n1000-s01729,absorbing,1000,1729,construction/public-consumed,0.1296554906304144,0.002585705626188428,0.12653417981346138,0.13120931274916076,0.1259790000040084,0.13189065100232256,8 +dtmc,absorbing-n1000-s01729,absorbing,1000,1729,evolution/k-10,0.0023010586881609535,2.6605452143357335e-06,0.0022992751632541926,0.0023062347906957397,0.0023004198003036434,0.002302903785935736,55 +dtmc,absorbing-n1000-s01729,absorbing,1000,1729,evolution/k-100,0.0229748348402178,2.810494166064631e-05,0.02294467071098754,0.022996831971865434,0.022954074163006974,0.02299409250069099,20 +dtmc,absorbing-n1000-s01729,absorbing,1000,1729,evolution/one-step,0.00023512637948530377,4.3016773425079945e-07,0.00023465197079564895,0.00023549503260659698,0.00023500042782673977,0.0002353078420319913,99 +dtmc,absorbing-n1000-s01729,absorbing,1000,1729,structure/classes-cold,0.04850358299639387,0.00015657325517774018,0.048122437510755844,0.04864631660748273,0.04543116700369865,0.04866015625157161,5 +dtmc,absorbing-n1000-s01729,absorbing,1000,1729,structure/classes-lifecycle,0.2369041250203736,0.001617156231077388,0.23623169159982355,0.238521281251451,0.23233783333368288,0.24339099999633618,5 +dtmc,absorbing-n1000-s01729,absorbing,1000,1729,structure/classes-warm/access,8.609160261363943e-09,1.0648381347832223e-10,8.513545495277762e-09,1.0848983341323523e-08,8.584282600673371e-09,8.668494202829671e-09,309 +dtmc,absorbing-n1000-s01729,absorbing,1000,1729,structure/classes-warm/consumed,5.100258099780055e-06,6.003844861612497e-09,5.096982285851355e-06,5.132273773475855e-06,5.0987383803805786e-06,5.10345690984851e-06,178 +dtmc,absorbing-n1000-s01729,absorbing,1000,1729,structure/irreducible-cold,0.04833490300613145,0.000677538595239946,0.04798225048580207,0.049012441601371394,0.04554049999569543,0.049032156261091586,5 +dtmc,absorbing-n1000-s01729,absorbing,1000,1729,structure/irreducible-warm,9.432625489095957e-09,1.2319779118952628e-10,9.321722529111121e-09,1.1846320073042687e-08,9.391402639211133e-09,9.532733561971537e-09,307 +dtmc,absorbing-n1000-s02718,absorbing,1000,2718,construction/public-consumed,0.1298133630476687,0.0022053335484261416,0.12769532025049557,0.13168811054092655,0.1274334479967365,0.13263804175221594,8 +dtmc,absorbing-n1000-s02718,absorbing,1000,2718,evolution/k-10,0.002299853484146297,1.4570294738268721e-06,0.00229892139695789,0.002302267827994182,0.0022993437494733373,0.00230058426955673,55 +dtmc,absorbing-n1000-s02718,absorbing,1000,2718,evolution/k-100,0.022993971297546524,5.496455996763065e-05,0.022957786791812394,0.02320815009387353,0.022960234500559246,0.023114140330686827,20 +dtmc,absorbing-n1000-s02718,absorbing,1000,2718,evolution/one-step,0.00023560528263272178,7.552813441438799e-07,0.000234882116197374,0.00023670287672368143,0.00023529663095749647,0.00023576024977955967,99 +dtmc,absorbing-n1000-s02718,absorbing,1000,2718,structure/classes-cold,0.048234391602454706,0.0001315586065174998,0.048102832995937206,0.048250239255139604,0.04612329101655632,0.049295222008368,5 +dtmc,absorbing-n1000-s02718,absorbing,1000,2718,structure/classes-lifecycle,0.23669422599705287,0.0021450901646555137,0.2356321002531331,0.23910189849812014,0.23370533350195427,0.24168037166479434,6 +dtmc,absorbing-n1000-s02718,absorbing,1000,2718,structure/classes-warm/access,8.61998614035359e-09,1.0823144127636321e-10,8.52372732805052e-09,1.0795154221670097e-08,8.568124442755809e-09,8.748671618188521e-09,309 +dtmc,absorbing-n1000-s02718,absorbing,1000,2718,structure/classes-warm/consumed,5.098942458083256e-06,6.9578684573052e-09,5.094211288455998e-06,5.1175493539705375e-06,5.09712814775761e-06,5.101520582176538e-06,178 +dtmc,absorbing-n1000-s02718,absorbing,1000,2718,structure/irreducible-cold,0.0478595104868873,0.0002911979754571803,0.04756831251143012,0.047951861003336184,0.045752375008305535,0.04881479180185124,5 +dtmc,absorbing-n1000-s02718,absorbing,1000,2718,structure/irreducible-warm,9.433379923343126e-09,1.1993833353155013e-10,9.323139002407918e-09,1.1866381292456453e-08,9.387809781712251e-09,9.514384942856188e-09,307 +dtmc,absorbing-n1000-s31415,absorbing,1000,31415,construction/public-consumed,0.12978664281157154,0.003348893065170444,0.12667972912277037,0.1328588531228888,0.12595379099366255,0.1360419374977937,8 +dtmc,absorbing-n1000-s31415,absorbing,1000,31415,evolution/k-10,0.0019508101898915785,1.8077570078641001e-06,0.0019489574825660829,0.0019523790273666094,0.0019500779491333979,0.0019515342563560505,58 +dtmc,absorbing-n1000-s31415,absorbing,1000,31415,evolution/k-100,0.01946035714354366,8.199874428100815e-05,0.019402350527040348,0.025436994236062875,0.019402520498260856,0.025020537055550247,19 +dtmc,absorbing-n1000-s31415,absorbing,1000,31415,evolution/one-step,0.00020332560309247334,5.931729543220737e-07,0.0002028659980961146,0.00020547512434845102,0.0002031297298799989,0.00020356249986338968,103 +dtmc,absorbing-n1000-s31415,absorbing,1000,31415,structure/classes-cold,0.04910085425217403,0.000915041753614787,0.04872427766288941,0.050186858390225096,0.048185812498559244,0.05169424999621697,5 +dtmc,absorbing-n1000-s31415,absorbing,1000,31415,structure/classes-lifecycle,0.2553057707482367,0.01292387524881633,0.24996581966600692,0.2724870249978267,0.24238189549942035,0.27570037500117905,5 +dtmc,absorbing-n1000-s31415,absorbing,1000,31415,structure/classes-warm/access,8.84106251191425e-09,3.3434256579458686e-10,8.554416637504166e-09,1.1601611395850252e-08,8.713751023097458e-09,8.959354122636102e-09,308 +dtmc,absorbing-n1000-s31415,absorbing,1000,31415,structure/classes-warm/consumed,5.100493782807664e-06,9.326127972288445e-09,5.093856877039325e-06,5.124925653273235e-06,5.097626626752079e-06,5.103566450991052e-06,178 +dtmc,absorbing-n1000-s31415,absorbing,1000,31415,structure/irreducible-cold,0.051412500004516914,0.0020655730040743947,0.05114539160276763,0.054321688003255986,0.04934692700044252,0.05794900000910275,5 +dtmc,absorbing-n1000-s31415,absorbing,1000,31415,structure/irreducible-warm,9.52581629627871e-09,2.1640597218069968e-10,9.330190050943357e-09,1.1961644485767104e-08,9.461574943067877e-09,9.646616524713121e-09,306 +dtmc,dense-n0010-s01729,dense,10,1729,construction/public-consumed,6.576903528425262e-06,1.187900206897468e-07,6.474168404451952e-06,6.72338905537294e-06,6.548444442968402e-06,6.616605891346925e-06,173 +dtmc,dense-n0010-s01729,dense,10,1729,evolution/k-10,1.6742999529621253e-06,2.948620342923429e-08,1.647997722394747e-06,1.7437675012600938e-06,1.6600920628805301e-06,1.6892188524219654e-06,199 +dtmc,dense-n0010-s01729,dense,10,1729,evolution/k-100,3.242753640127679e-06,6.473537986670031e-08,3.2050067633118342e-06,3.3704097940753136e-06,3.2307692051220397e-06,3.2608487578890457e-06,187 +dtmc,dense-n0010-s01729,dense,10,1729,evolution/one-step,2.4424118918716585e-07,9.222008336631835e-09,2.3498788620614206e-07,2.505841162316849e-07,2.402303671935805e-07,2.451478850093021e-07,241 +dtmc,dense-n0010-s01729,dense,10,1729,finite-time/n-step/k-10,2.9863319165694215e-06,6.048463142683932e-08,2.938028862462118e-06,3.1165170091311015e-06,2.9662469558320674e-06,3.0289534255935084e-06,163 +dtmc,dense-n0010-s01729,dense,10,1729,finite-time/n-step/k-100,1.7609728737768372e-05,6.162577075482289e-08,1.7564211165764884e-05,1.788248035083728e-05,1.7588236092013264e-05,1.7641865027447542e-05,139 +dtmc,dense-n0010-s01729,dense,10,1729,finite-time/observation/k-10,3.4582549160982053e-06,7.004092704020769e-08,3.4046250305927443e-06,3.5705483678768034e-06,3.4487488512527012e-06,3.487919509338145e-06,160 +dtmc,dense-n0010-s01729,dense,10,1729,finite-time/observation/k-100,1.8789855988721472e-05,3.89290327883363e-07,1.8374509155913225e-05,1.912680239363116e-05,1.868340355270591e-05,1.887778366296315e-05,138 +dtmc,dense-n0010-s01729,dense,10,1729,finite-time/step,8.128676920456446e-07,2.1555162555870628e-08,7.952114637770114e-07,8.40941667089257e-07,8.071147021837533e-07,8.180973796399037e-07,190 +dtmc,dense-n0010-s01729,dense,10,1729,hitting-probability/cold-all-states,1.951978522612265e-05,4.169295579194472e-07,1.904832303259137e-05,1.9883052388165172e-05,1.9451046278441532e-05,1.9672029698215482e-05,132 +dtmc,dense-n0010-s01729,dense,10,1729,hitting-probability/warm-lookup,2.585666474768849e-08,7.895836006501991e-10,2.5262806402528943e-08,2.827562597948464e-08,2.5654471537259834e-08,2.6000626352914285e-08,286 +dtmc,dense-n0010-s01729,dense,10,1729,hitting-time/cold-all-states,1.7781745061014158e-05,2.687044500451904e-07,1.750537898849768e-05,1.802701700768953e-05,1.769440146275766e-05,1.7864356321903566e-05,133 +dtmc,dense-n0010-s01729,dense,10,1729,hitting-time/warm-lookup,2.6192663982424808e-08,1.6395486986715696e-09,2.4778728552069823e-08,3.054223098059955e-08,2.577819196456095e-08,2.679896246891108e-08,284 +dtmc,dense-n0010-s01729,dense,10,1729,hitting/bounded/at-most/k-10,3.5293394501592998e-06,8.103198616511227e-08,3.468332331124518e-06,3.6251735357995384e-06,3.506708099748193e-06,3.5541125648737774e-06,160 +dtmc,dense-n0010-s01729,dense,10,1729,hitting/bounded/at-most/k-100,2.0053018024452867e-05,4.135573018956761e-07,1.963946072255719e-05,2.045391885039644e-05,1.9945698624078726e-05,2.0184418135028096e-05,137 +dtmc,dense-n0010-s01729,dense,10,1729,hitting/bounded/exact/k-10,3.391154228389814e-06,7.946882676958792e-08,3.3234764852368234e-06,3.4891990061522787e-06,3.3671878389379177e-06,3.4144051479981157e-06,159 +dtmc,dense-n0010-s01729,dense,10,1729,hitting/bounded/exact/k-100,1.9864442079919033e-05,4.634430717067945e-07,1.929657031802e-05,2.021208991099036e-05,1.9719101854005e-05,1.997487521283382e-05,137 +dtmc,dense-n0010-s01729,dense,10,1729,hitting/bounded/greater-than/k-10,3.487996374523001e-06,9.339579904277975e-08,3.416749677853659e-06,3.63437611667905e-06,3.465467741858243e-06,3.5344317777428864e-06,161 +dtmc,dense-n0010-s01729,dense,10,1729,hitting/bounded/greater-than/k-100,1.987723989455559e-05,2.1506866658796317e-07,1.966322618853796e-05,2.0098992232912376e-05,1.9796899412574665e-05,1.994255682348595e-05,137 +dtmc,dense-n0010-s01729,dense,10,1729,power/10,4.921212843782384e-06,2.402927690311238e-07,4.743193947396488e-06,5.3381091678936e-06,4.839654978910101e-06,5.032964082167864e-06,177 +dtmc,dense-n0010-s01729,dense,10,1729,power/100,6.020228777612959e-06,1.940425258411581e-07,5.887630227435794e-06,6.326400034595281e-06,5.9594359429012255e-06,6.083181391292486e-06,173 +dtmc,dense-n0010-s01729,dense,10,1729,power/2,3.578652824746419e-06,7.255825052150412e-08,3.5168712455956365e-06,3.689390776572362e-06,3.554971087675018e-06,3.610017491177956e-06,184 +dtmc,dense-n0010-s01729,dense,10,1729,race/forward-committor,1.9005750068078766e-05,1.0840803078630463e-06,1.8011377450844337e-05,2.0215608134472652e-05,1.8724118984816105e-05,1.924910682618564e-05,134 +dtmc,dense-n0010-s01729,dense,10,1729,return/bounded/k-10,3.221307102089318e-06,6.773168856642022e-08,3.154832975809822e-06,3.2902409584685697e-06,3.1923436366026447e-06,3.2424906033148733e-06,161 +dtmc,dense-n0010-s01729,dense,10,1729,return/bounded/k-100,1.987557884642244e-05,3.551916194976833e-07,1.9582763473278775e-05,2.029986739925117e-05,1.979914617826396e-05,1.9949305367291622e-05,137 +dtmc,dense-n0010-s01729,dense,10,1729,return/mean-recurrence,8.81519435611351e-06,2.8725636267335867e-07,8.5194589613996e-06,9.072471125010759e-06,8.7135580542963e-06,8.88762207954133e-06,142 +dtmc,dense-n0010-s01729,dense,10,1729,simulation/10000,0.006924221133882476,0.00017746222369768123,0.006648126814070565,0.007014325625641504,0.006804412808768185,0.007006014920189045,36 +dtmc,dense-n0010-s01729,dense,10,1729,simulation/100000,0.06867391699779546,0.0012104021710304808,0.068377684859297,0.07043932608454875,0.06830620312393876,0.07099433300027158,11 +dtmc,dense-n0010-s01729,dense,10,1729,stationary,8.351876751171867e-06,2.446021518645674e-07,8.136266291152397e-06,8.635176923726311e-06,8.309449560789892e-06,8.45225117038212e-06,142 +dtmc,dense-n0010-s01729,dense,10,1729,structure/classes-cold,3.827708975243057e-06,7.320526935864365e-08,3.756750445906718e-06,3.906904989936419e-06,3.8094117992309546e-06,3.842873598564452e-06,158 +dtmc,dense-n0010-s01729,dense,10,1729,structure/classes-lifecycle,9.626877344521147e-06,1.9263190653321908e-07,9.447925185668282e-06,9.848090283210493e-06,9.569674843471738e-06,9.692462413601133e-06,165 +dtmc,dense-n0010-s01729,dense,10,1729,structure/classes-warm/access,9.254922080127627e-09,3.983917682407615e-10,9.071387640279272e-09,1.1609697353887383e-08,9.201108155224593e-09,9.332657335771073e-09,307 +dtmc,dense-n0010-s01729,dense,10,1729,structure/classes-warm/consumed,4.404475743498695e-08,1.15665302964481e-09,4.3168238248089633e-08,4.777424064563527e-08,4.382897639138471e-08,4.421967413511786e-08,275 +dtmc,dense-n0010-s01729,dense,10,1729,structure/irreducible-cold,2.694617024920771e-06,7.44948587678401e-08,2.5966252628355978e-06,2.7487557923403742e-06,2.652611660934186e-06,2.7090618159587923e-06,165 +dtmc,dense-n0010-s01729,dense,10,1729,structure/irreducible-warm,1.0496747143478861e-08,3.8618784443048915e-10,1.022616661239755e-08,1.2974338367199286e-08,1.0438669659778198e-08,1.0606460439461877e-08,305 +dtmc,dense-n0010-s01729,dense,10,1729,visits/bounded-expectation/k-10,5.504302680492401e-06,1.3291175254499147e-07,5.389607233357512e-06,5.6576252782110716e-06,5.451283408525254e-06,5.537031108078523e-06,151 +dtmc,dense-n0010-s01729,dense,10,1729,visits/bounded-expectation/k-100,3.8817863955333914e-05,8.683190801354206e-07,3.809961522008032e-05,3.9764040465136674e-05,3.859552472070056e-05,3.9108916237731545e-05,128 +dtmc,dense-n0010-s02718,dense,10,2718,construction/public-consumed,6.77747899961365e-06,1.1272076631499709e-07,6.687843712087952e-06,6.988405860284308e-06,6.749999762002018e-06,6.813305847439411e-06,171 +dtmc,dense-n0010-s02718,dense,10,2718,evolution/k-10,1.807492115179056e-06,4.191766431524141e-08,1.7626149799320942e-06,1.8444980408304764e-06,1.7965289503883789e-06,1.8150849272501748e-06,199 +dtmc,dense-n0010-s02718,dense,10,2718,evolution/k-100,3.393157028734701e-06,7.587349604903514e-08,3.3228772777365346e-06,3.469533221355963e-06,3.381228853480084e-06,3.416725601329135e-06,186 +dtmc,dense-n0010-s02718,dense,10,2718,evolution/one-step,2.6423999651663713e-07,9.04069376907564e-09,2.576634195842893e-07,2.774598456163943e-07,2.6248179108417225e-07,2.6593117361346337e-07,239 +dtmc,dense-n0010-s02718,dense,10,2718,finite-time/n-step/k-10,2.928358261330265e-06,1.1103022734437642e-08,2.918839178523815e-06,2.944446501202174e-06,2.9255223293100723e-06,2.9314306582585107e-06,164 +dtmc,dense-n0010-s02718,dense,10,2718,finite-time/n-step/k-100,1.7445053600434787e-05,4.01314133519627e-08,1.741926348353621e-05,1.7530578998685405e-05,1.7433325047022664e-05,1.7456769030420677e-05,140 +dtmc,dense-n0010-s02718,dense,10,2718,finite-time/observation/k-10,3.4262977073735614e-06,3.784154461223522e-08,3.3973216522396437e-06,3.4814128140526015e-06,3.418411079378909e-06,3.4400841839841204e-06,160 +dtmc,dense-n0010-s02718,dense,10,2718,finite-time/observation/k-100,1.807802950723766e-05,6.928704819261438e-08,1.80226093268951e-05,1.8254234485147152e-05,1.8044570294607964e-05,1.8113917892095536e-05,139 +dtmc,dense-n0010-s02718,dense,10,2718,finite-time/step,7.626330579056385e-07,8.286796549639628e-09,7.565677566818438e-07,7.749627155590212e-07,7.610326802760766e-07,7.657263754462678e-07,191 +dtmc,dense-n0010-s02718,dense,10,2718,hitting-probability/cold-all-states,1.8538463896570298e-05,5.225878447570664e-07,1.80469021128798e-05,1.9084352787783764e-05,1.8310204689408204e-05,1.8681417485840582e-05,133 +dtmc,dense-n0010-s02718,dense,10,2718,hitting-probability/warm-lookup,2.5789030074522253e-08,8.551363447566837e-10,2.513350172701939e-08,2.9017818243508893e-08,2.554632496664796e-08,2.6033551190863442e-08,285 +dtmc,dense-n0010-s02718,dense,10,2718,hitting-time/cold-all-states,1.7618762822420458e-05,6.668651282931039e-07,1.707080173576918e-05,1.8617103381835127e-05,1.744483326239368e-05,1.795278432781774e-05,134 +dtmc,dense-n0010-s02718,dense,10,2718,hitting-time/warm-lookup,2.5693212023717907e-08,1.17690677318449e-09,2.4686566967126306e-08,3.0143523307841127e-08,2.540691661049369e-08,2.607597664877046e-08,286 +dtmc,dense-n0010-s02718,dense,10,2718,hitting/bounded/at-most/k-10,3.3907810092515326e-06,6.60928104305342e-08,3.3366237481750806e-06,3.5239268240898297e-06,3.3734968381110585e-06,3.404620767403519e-06,161 +dtmc,dense-n0010-s02718,dense,10,2718,hitting/bounded/at-most/k-100,1.906032462055283e-05,1.297305529476906e-07,1.8950006686481453e-05,1.9309911811883065e-05,1.900988772633453e-05,1.9109226952046748e-05,139 +dtmc,dense-n0010-s02718,dense,10,2718,hitting/bounded/exact/k-10,3.3037565952661088e-06,2.1899385111672768e-08,3.28336263919482e-06,3.3354551826849662e-06,3.2957002986222504e-06,3.3113042174555435e-06,161 +dtmc,dense-n0010-s02718,dense,10,2718,hitting/bounded/exact/k-100,1.895278506961127e-05,1.3957265561023464e-07,1.8843220260769702e-05,1.9158389136104445e-05,1.893513466032596e-05,1.9006937236554222e-05,139 +dtmc,dense-n0010-s02718,dense,10,2718,hitting/bounded/greater-than/k-10,3.2517867673069557e-06,2.5498273141918245e-08,3.2294173392919746e-06,3.2873214347163187e-06,3.245260603998157e-06,3.2571539835298017e-06,161 +dtmc,dense-n0010-s02718,dense,10,2718,hitting/bounded/greater-than/k-100,1.990877324629736e-05,4.134326605893787e-07,1.947833404588647e-05,2.0293038178240965e-05,1.9765232741488267e-05,2.0039553132128756e-05,138 +dtmc,dense-n0010-s02718,dense,10,2718,power/10,5.010223193942695e-06,3.012949443226042e-07,4.732858689512004e-06,5.411742242140604e-06,4.961164962066319e-06,5.108461553900303e-06,180 +dtmc,dense-n0010-s02718,dense,10,2718,power/100,6.009098817221691e-06,2.4124245022277554e-07,5.790135797526771e-06,6.317535118041367e-06,5.881366375940389e-06,6.100910644407474e-06,173 +dtmc,dense-n0010-s02718,dense,10,2718,power/2,3.767573387801437e-06,2.0742777597925222e-07,3.603013990666821e-06,4.175962746877528e-06,3.7024282002156335e-06,3.860077700938552e-06,183 +dtmc,dense-n0010-s02718,dense,10,2718,race/forward-committor,1.6664031482789488e-05,2.0007388095334502e-07,1.6507608882137543e-05,1.7030456661585504e-05,1.6611215771250555e-05,1.6771876677946264e-05,135 +dtmc,dense-n0010-s02718,dense,10,2718,return/bounded/k-10,3.1660834612394275e-06,7.13236933674695e-08,3.110661796663849e-06,3.247184136002064e-06,3.1448258725913046e-06,3.1902979956285008e-06,162 +dtmc,dense-n0010-s02718,dense,10,2718,return/bounded/k-100,1.934089991592041e-05,2.629362569945995e-07,1.9107614556105595e-05,1.9669584278245548e-05,1.926413768002979e-05,1.944127021375949e-05,138 +dtmc,dense-n0010-s02718,dense,10,2718,return/mean-recurrence,8.14972471517978e-06,2.0513610564955987e-07,7.9719698738236e-06,8.397931175305936e-06,8.084195125716617e-06,8.245048678834189e-06,142 +dtmc,dense-n0010-s02718,dense,10,2718,simulation/10000,0.006692619934762107,0.00036843536978384706,0.00630842002647114,0.00704160130493036,0.006427928715960921,0.006920450590603816,36 +dtmc,dense-n0010-s02718,dense,10,2718,simulation/100000,0.06793982299859636,0.0017725936680411253,0.06650177413879041,0.06959013323382048,0.06604918044467922,0.06971241666663748,11 +dtmc,dense-n0010-s02718,dense,10,2718,stationary,7.742546731986894e-06,2.042414468341033e-07,7.550510779524006e-06,7.954603309675198e-06,7.668864014836963e-06,7.812204591280108e-06,144 +dtmc,dense-n0010-s02718,dense,10,2718,structure/classes-cold,3.6476005334407093e-06,9.154862613956423e-08,3.570226635302192e-06,3.7730516205605543e-06,3.617139125983055e-06,3.6872604223796356e-06,159 +dtmc,dense-n0010-s02718,dense,10,2718,structure/classes-lifecycle,9.148136706055894e-06,3.001304730276698e-07,8.928350820369496e-06,9.608285966593462e-06,9.026545078747652e-06,9.285435213961104e-06,165 +dtmc,dense-n0010-s02718,dense,10,2718,structure/classes-warm/access,8.993036892947399e-09,4.486902917276613e-10,8.599264364020591e-09,1.1709846228688626e-08,8.849570492962496e-09,9.161428716131952e-09,308 +dtmc,dense-n0010-s02718,dense,10,2718,structure/classes-warm/consumed,4.3261558834449815e-08,2.104135295704281e-09,4.123081597907736e-08,4.660127606043744e-08,4.30665304580294e-08,4.3650280633112864e-08,276 +dtmc,dense-n0010-s02718,dense,10,2718,structure/irreducible-cold,2.571308818579837e-06,6.88193587713478e-08,2.515376097983228e-06,2.661816811692964e-06,2.5523785049883243e-06,2.6039997464977205e-06,166 +dtmc,dense-n0010-s02718,dense,10,2718,structure/irreducible-warm,1.0166693193278905e-08,4.962589153992721e-10,9.80112482590658e-09,1.2788002060938486e-08,1.0082755903698263e-08,1.0240145163094911e-08,305 +dtmc,dense-n0010-s02718,dense,10,2718,visits/bounded-expectation/k-10,5.20495988894254e-06,6.679287493307977e-08,5.145940090903333e-06,5.2978958841583185e-06,5.191000026469636e-06,5.230647286421409e-06,151 +dtmc,dense-n0010-s02718,dense,10,2718,visits/bounded-expectation/k-100,3.8548284161758296e-05,6.184300635080937e-07,3.775935094183458e-05,3.903914125190781e-05,3.8328705058019194e-05,3.8740253685164596e-05,129 +dtmc,dense-n0010-s31415,dense,10,31415,construction/public-consumed,6.757749014511882e-06,1.863060118865103e-07,6.6353796163249555e-06,7.0565946509543006e-06,6.71791637894018e-06,6.841581970228157e-06,172 +dtmc,dense-n0010-s31415,dense,10,31415,evolution/k-10,1.8061735950734303e-06,6.091827246055227e-08,1.7664165680834345e-06,1.8790912934792716e-06,1.795196704072827e-06,1.8256462977205422e-06,199 +dtmc,dense-n0010-s31415,dense,10,31415,evolution/k-100,3.4451972443144663e-06,1.5781872306014426e-07,3.288527563713416e-06,3.604232610789702e-06,3.395871944097338e-06,3.495400147078599e-06,184 +dtmc,dense-n0010-s31415,dense,10,31415,evolution/one-step,2.6314901112981175e-07,8.956093303810665e-09,2.556257428871437e-07,2.773155953593508e-07,2.6107305874336397e-07,2.6524736013109844e-07,239 +dtmc,dense-n0010-s31415,dense,10,31415,finite-time/n-step/k-10,3.1708409305772888e-06,8.580831896486707e-08,3.0988258509346956e-06,3.2729859891416016e-06,3.1501731427852064e-06,3.2007261655632067e-06,162 +dtmc,dense-n0010-s31415,dense,10,31415,finite-time/n-step/k-100,1.887233264959774e-05,6.993319914281022e-07,1.8291696083185668e-05,1.987650376922202e-05,1.8627048424190347e-05,1.927024503502556e-05,138 +dtmc,dense-n0010-s31415,dense,10,31415,finite-time/observation/k-10,3.845701468418594e-06,1.195856304964683e-07,3.7303595429416515e-06,3.959201741310967e-06,3.825436579063535e-06,3.862005242610296e-06,159 +dtmc,dense-n0010-s31415,dense,10,31415,finite-time/observation/k-100,1.8959514111176963e-05,3.2194708651412206e-07,1.86989548892908e-05,1.937420134757984e-05,1.887321654383255e-05,1.903405834181125e-05,137 +dtmc,dense-n0010-s31415,dense,10,31415,finite-time/step,8.034367709626962e-07,2.1800005917503403e-08,7.824481323697283e-07,8.252870801397621e-07,7.977152043687446e-07,8.083996362984181e-07,189 +dtmc,dense-n0010-s31415,dense,10,31415,hitting-probability/cold-all-states,1.7756758225409105e-05,2.381426771616554e-07,1.7571838171275582e-05,1.811652337455985e-05,1.7667375171087568e-05,1.787789156166938e-05,134 +dtmc,dense-n0010-s31415,dense,10,31415,hitting-probability/warm-lookup,2.5247855993598816e-08,1.451125905714476e-09,2.439579339057529e-08,2.979075643494592e-08,2.5161650912838813e-08,2.5576601705728744e-08,284 +dtmc,dense-n0010-s31415,dense,10,31415,hitting-time/cold-all-states,1.668366759851644e-05,3.486652362712278e-07,1.6368208485396786e-05,1.7085408086479844e-05,1.6625902909814882e-05,1.6809170416311804e-05,135 +dtmc,dense-n0010-s31415,dense,10,31415,hitting-time/warm-lookup,2.5961305023124262e-08,1.0517361992301665e-09,2.5167757247691584e-08,2.9567306974863164e-08,2.564877585571095e-08,2.625656858820883e-08,286 +dtmc,dense-n0010-s31415,dense,10,31415,hitting/bounded/at-most/k-10,3.750144478777577e-06,1.822986428740176e-07,3.5282220143078405e-06,3.884966270272143e-06,3.6975480789082153e-06,3.7954191573574636e-06,159 +dtmc,dense-n0010-s31415,dense,10,31415,hitting/bounded/at-most/k-100,2.043275504784442e-05,3.90186219811423e-07,2.0032751698246492e-05,2.0760807537077695e-05,2.027861326733539e-05,2.0523977478276783e-05,137 +dtmc,dense-n0010-s31415,dense,10,31415,hitting/bounded/exact/k-10,3.7182695382534656e-06,2.3244180888319228e-07,3.4702777626681278e-06,3.921538561316774e-06,3.6709041190447556e-06,3.7741433207916366e-06,160 +dtmc,dense-n0010-s31415,dense,10,31415,hitting/bounded/exact/k-100,1.9508579971216496e-05,2.770646151145836e-07,1.928557985988648e-05,1.982460247260889e-05,1.943697047940755e-05,1.9632634744098893e-05,137 +dtmc,dense-n0010-s31415,dense,10,31415,hitting/bounded/greater-than/k-10,3.5483156409501155e-06,9.494119174061486e-08,3.450908676441702e-06,3.6371708414957833e-06,3.5219773006595216e-06,3.5797924936903308e-06,160 +dtmc,dense-n0010-s31415,dense,10,31415,hitting/bounded/greater-than/k-100,1.998418701987248e-05,3.6032169021827645e-07,1.9626674581507832e-05,2.0344508710090756e-05,1.991281698627228e-05,2.004825649320921e-05,137 +dtmc,dense-n0010-s31415,dense,10,31415,power/10,4.731500262601508e-06,1.4011387898783215e-07,4.621371024158588e-06,4.9140450786119645e-06,4.68473347912853e-06,4.7705009320095654e-06,179 +dtmc,dense-n0010-s31415,dense,10,31415,power/100,5.781887828524472e-06,7.52545861514649e-08,5.730846372370219e-06,5.979040909549021e-06,5.753073815463318e-06,5.8351300970610716e-06,175 +dtmc,dense-n0010-s31415,dense,10,31415,power/2,3.7933141667200137e-06,1.151875173358292e-07,3.593972062947653e-06,3.885868626275011e-06,3.7849312241469773e-06,3.8021662592219805e-06,184 +dtmc,dense-n0010-s31415,dense,10,31415,race/forward-committor,1.7107405801492202e-05,4.054038381296021e-07,1.676016611110991e-05,1.769845371425824e-05,1.6978872590930758e-05,1.727862672851188e-05,134 +dtmc,dense-n0010-s31415,dense,10,31415,return/bounded/k-10,3.3788808822841968e-06,1.3571615055131655e-07,3.2187314235042954e-06,3.492056206522296e-06,3.3294685364832203e-06,3.3988379838311445e-06,161 +dtmc,dense-n0010-s31415,dense,10,31415,return/bounded/k-100,1.9038513546154647e-05,2.820057966843707e-07,1.8800253337270886e-05,1.934758975752456e-05,1.897528273019745e-05,1.912879749725121e-05,138 +dtmc,dense-n0010-s31415,dense,10,31415,return/mean-recurrence,8.239498648825766e-06,1.8299291526531148e-07,8.090798170693839e-06,8.515901869974032e-06,8.196525723366163e-06,8.324997907038778e-06,141 +dtmc,dense-n0010-s31415,dense,10,31415,simulation/10000,0.006703108483249837,0.00028991219128776755,0.0063738553358451185,0.006912734334643271,0.006434431651180761,0.006841541493486147,36 +dtmc,dense-n0010-s31415,dense,10,31415,simulation/100000,0.07380285639956127,0.002061814648290493,0.07260332441046558,0.07714393450094373,0.0723290398106753,0.08087102056221025,10 +dtmc,dense-n0010-s31415,dense,10,31415,stationary,7.3198967498154504e-06,1.3406840902369213e-07,7.216874651401509e-06,7.566513137141251e-06,7.270021780817821e-06,7.38196052961506e-06,144 +dtmc,dense-n0010-s31415,dense,10,31415,structure/classes-cold,3.6016211896892524e-06,7.285520821947292e-08,3.531098771159003e-06,3.6739542283374193e-06,3.5867734095159e-06,3.6250009240272143e-06,159 +dtmc,dense-n0010-s31415,dense,10,31415,structure/classes-lifecycle,8.984313555901581e-06,2.4340071216266094e-07,8.77899963044278e-06,9.396870167162356e-06,8.890431464131751e-06,9.13823835353724e-06,165 +dtmc,dense-n0010-s31415,dense,10,31415,structure/classes-warm/access,9.279331185974653e-09,3.7834095662457897e-10,9.01160963234731e-09,1.1757845398330924e-08,9.196746265980192e-09,9.415717207726564e-09,307 +dtmc,dense-n0010-s31415,dense,10,31415,structure/classes-warm/consumed,4.316047550381171e-08,1.5308879701029428e-09,4.1815058151543524e-08,4.632267522224499e-08,4.290099184615936e-08,4.3583886017168595e-08,276 +dtmc,dense-n0010-s31415,dense,10,31415,structure/irreducible-cold,2.5587772133668913e-06,5.482596594250663e-08,2.5171313216167226e-06,2.6303811624408395e-06,2.5380694936211484e-06,2.574568084927944e-06,166 +dtmc,dense-n0010-s31415,dense,10,31415,structure/irreducible-warm,1.00164240616004e-08,4.479409549915092e-10,9.634120762482463e-09,1.2739832300212584e-08,9.850183040985834e-09,1.0291912075841608e-08,306 +dtmc,dense-n0010-s31415,dense,10,31415,visits/bounded-expectation/k-10,5.308382036752281e-06,7.505153985498066e-08,5.229040352984077e-06,5.37083307962575e-06,5.299636634364192e-06,5.325286627180398e-06,151 +dtmc,dense-n0010-s31415,dense,10,31415,visits/bounded-expectation/k-100,3.8602300517456854e-05,6.729499344576765e-07,3.769425287221869e-05,3.9027739721522836e-05,3.830747266965358e-05,3.875666637516891e-05,129 +dtmc,dense-n0025-s01729,dense,25,1729,construction/public-consumed,4.032969540592445e-05,1.6142085863683807e-06,3.872711261690586e-05,4.1905625461984694e-05,3.952651078340269e-05,4.083014451610149e-05,135 +dtmc,dense-n0025-s01729,dense,25,1729,evolution/k-10,2.458821813422994e-06,5.91688214089243e-08,2.4131254852949244e-06,2.530295618767427e-06,2.445053955763761e-06,2.480340162980225e-06,193 +dtmc,dense-n0025-s01729,dense,25,1729,evolution/k-100,1.055645383559949e-05,7.011634377391917e-07,1.0065696091930332e-05,1.1482853416281289e-05,1.03575231885847e-05,1.0858946074685995e-05,163 +dtmc,dense-n0025-s01729,dense,25,1729,evolution/one-step,4.403205257285583e-07,2.660193746490147e-08,4.217365946130415e-07,4.825038517263668e-07,4.3376316272925357e-07,4.489763554705155e-07,229 +dtmc,dense-n0025-s01729,dense,25,1729,finite-time/n-step/k-10,1.7702496666718136e-05,2.192098134680697e-06,1.5823225780400548e-05,2.0752000749343818e-05,1.7021688766151025e-05,1.8168554786431794e-05,122 +dtmc,dense-n0025-s01729,dense,25,1729,finite-time/n-step/k-100,0.00010382991644696126,5.21380611139143e-06,9.90077628160869e-05,0.00011135681179348277,0.00010196368269757123,0.00010552081619931563,91 +dtmc,dense-n0025-s01729,dense,25,1729,finite-time/observation/k-10,1.5903235422029622e-05,6.1664049209480645e-06,6.056054639350698e-06,1.969636497795529e-05,1.1060651290086164e-05,1.8233227975932616e-05,151 +dtmc,dense-n0025-s01729,dense,25,1729,finite-time/observation/k-100,2.794560121549666e-05,7.30089326410692e-07,2.6788767894368716e-05,2.8463472260816216e-05,2.773883878356848e-05,2.8059879148829582e-05,118 +dtmc,dense-n0025-s01729,dense,25,1729,finite-time/step,5.0581356283502456e-06,7.088144621724814e-07,4.482451617217588e-06,6.492433484599875e-06,4.821500278055846e-06,5.324437033875735e-06,147 +dtmc,dense-n0025-s01729,dense,25,1729,hitting-probability/cold-all-states,0.0001230393910039614,9.124140704097099e-06,0.0001142509919591248,0.00013219638271512438,0.00011758016310368646,0.00012578529812243587,85 +dtmc,dense-n0025-s01729,dense,25,1729,hitting-probability/warm-lookup,1.6116238021234494e-07,4.8939989112654085e-08,1.1847762483741522e-07,2.3557703780870025e-07,1.4653527313247208e-07,1.733581684275054e-07,253 +dtmc,dense-n0025-s01729,dense,25,1729,hitting-time/cold-all-states,0.00028056877578891225,3.613198878673219e-05,0.00024789532759122697,0.0003177604649754815,0.0002686213874767418,0.0002955231471720186,73 +dtmc,dense-n0025-s01729,dense,25,1729,hitting-time/warm-lookup,9.634331078581083e-08,9.044359080083752e-09,9.217644332278308e-08,1.0863976996576612e-07,9.537095891306715e-08,9.747256100123939e-08,259 +dtmc,dense-n0025-s01729,dense,25,1729,hitting/bounded/at-most/k-10,4.8170405886951905e-06,2.1891565540449324e-07,4.634760923747298e-06,5.056953530885189e-06,4.76279237165234e-06,4.896980349843547e-06,152 +dtmc,dense-n0025-s01729,dense,25,1729,hitting/bounded/at-most/k-100,2.7948444651898056e-05,7.269248409442648e-07,2.7182824823930116e-05,2.8609880696945056e-05,2.769799993984634e-05,2.8199552425097575e-05,119 +dtmc,dense-n0025-s01729,dense,25,1729,hitting/bounded/exact/k-10,5.119047352721934e-06,1.837648753706921e-07,4.964776631731932e-06,5.3545706274841604e-06,5.0807253454079805e-06,5.166799890334684e-06,152 +dtmc,dense-n0025-s01729,dense,25,1729,hitting/bounded/exact/k-100,2.6796364220493333e-05,4.6230658466268296e-07,2.64414604169956e-05,2.7293859579888813e-05,2.6621768483892083e-05,2.6909496227744967e-05,119 +dtmc,dense-n0025-s01729,dense,25,1729,hitting/bounded/greater-than/k-10,5.035834409757599e-06,1.218461260905479e-07,4.887741367761674e-06,5.152624512708742e-06,4.996877078573706e-06,5.064344150014222e-06,153 +dtmc,dense-n0025-s01729,dense,25,1729,hitting/bounded/greater-than/k-100,2.738750081334729e-05,6.7832252627598e-07,2.6752657551501933e-05,2.812571259058116e-05,2.711609098745661e-05,2.763297286517709e-05,119 +dtmc,dense-n0025-s01729,dense,25,1729,power/10,2.309726253907536e-05,1.1713559743994388e-06,2.2021638749864577e-05,2.4421110325554572e-05,2.2660298502439848e-05,2.3420253175657674e-05,146 +dtmc,dense-n0025-s01729,dense,25,1729,power/100,2.7136027711094357e-05,1.1565422260083767e-06,2.6217131329950905e-05,2.8305702988927813e-05,2.690054844283769e-05,2.7352082826664274e-05,142 +dtmc,dense-n0025-s01729,dense,25,1729,power/2,1.5402049757540227e-05,1.9553996129747187e-06,1.374601239755672e-05,1.7815392836697628e-05,1.4905364051545886e-05,1.5749000000740345e-05,151 +dtmc,dense-n0025-s01729,dense,25,1729,race/forward-committor,0.00020552577933163516,1.6067136331143986e-05,0.00019314731626208966,0.0002349335683318228,0.00020190549319041226,0.00021373617153594594,76 +dtmc,dense-n0025-s01729,dense,25,1729,return/bounded/k-10,4.638180333999622e-06,2.0993851069040642e-07,4.375286632277116e-06,4.7616758205009315e-06,4.567225062234475e-06,4.671248865050678e-06,154 +dtmc,dense-n0025-s01729,dense,25,1729,return/bounded/k-100,2.7307913767652132e-05,6.63421686260485e-07,2.6667054541180573e-05,2.8058186070225313e-05,2.7111717561606022e-05,2.7463373734117968e-05,119 +dtmc,dense-n0025-s01729,dense,25,1729,return/mean-recurrence,2.7462888586645324e-05,1.1793866481942424e-06,2.618863806421986e-05,2.8555769448775762e-05,2.6836714650493204e-05,2.7930180955564184e-05,117 +dtmc,dense-n0025-s01729,dense,25,1729,simulation/10000,0.007303329001297243,9.138243040069868e-05,0.007213689347554464,0.007398016990457166,0.007226088775261756,0.007387873466151567,35 +dtmc,dense-n0025-s01729,dense,25,1729,simulation/100000,0.07004441666989199,0.0011485290286752103,0.06887704782529909,0.07090836884672172,0.06884335424911114,0.0711929456985672,11 +dtmc,dense-n0025-s01729,dense,25,1729,stationary,4.861828494520321e-05,3.1646246716810767e-06,4.5776942539360434e-05,5.379810405578142e-05,4.7349338017400626e-05,4.985041294817115e-05,104 +dtmc,dense-n0025-s01729,dense,25,1729,structure/classes-cold,1.584700500891565e-05,5.892058404490615e-07,1.5428969087252457e-05,1.6612230009135266e-05,1.5766123205570405e-05,1.6072082728710267e-05,127 +dtmc,dense-n0025-s01729,dense,25,1729,structure/classes-lifecycle,8.468942860035742e-05,2.005015483096039e-06,8.354572575658856e-05,8.811806377363265e-05,8.418590396803875e-05,8.579998353121078e-05,121 +dtmc,dense-n0025-s01729,dense,25,1729,structure/classes-warm/access,1.1896012570800879e-08,4.262485479412333e-10,1.1616781949686482e-08,1.466484036092905e-08,1.1795415559031047e-08,1.2066090284602927e-08,302 +dtmc,dense-n0025-s01729,dense,25,1729,structure/classes-warm/consumed,1.5946068155715795e-07,6.164488199664325e-09,1.5519802011365052e-07,1.7424992455000227e-07,1.5857051886381018e-07,1.6087164526940973e-07,249 +dtmc,dense-n0025-s01729,dense,25,1729,structure/irreducible-cold,1.4727168119090304e-05,1.0093182457635204e-06,1.3621080460512848e-05,1.560562377021112e-05,1.4447405308550998e-05,1.5056042528733566e-05,128 +dtmc,dense-n0025-s01729,dense,25,1729,structure/irreducible-warm,1.8748906825724852e-08,1.0973109292807772e-09,1.8046901816471923e-08,2.4628215034128678e-08,1.8517336801532866e-08,1.9376630631583695e-08,290 +dtmc,dense-n0025-s01729,dense,25,1729,visits/bounded-expectation/k-10,7.182816855580561e-06,2.2459198157946536e-07,6.841256299427959e-06,7.325772991287414e-06,7.092156896295697e-06,7.217248216167921e-06,145 +dtmc,dense-n0025-s01729,dense,25,1729,visits/bounded-expectation/k-100,4.7932675580756323e-05,1.1996258858275267e-06,4.665800544311031e-05,4.902786370758061e-05,4.752253733570112e-05,4.820048161768149e-05,115 +dtmc,dense-n0025-s02718,dense,25,2718,construction/public-consumed,4.088765822013522e-05,5.747167381552613e-07,4.036943341770434e-05,4.155447866769531e-05,4.0724773016582065e-05,4.103870460159587e-05,135 +dtmc,dense-n0025-s02718,dense,25,2718,evolution/k-10,2.555394765757486e-06,5.984628386489276e-08,2.4938205603556164e-06,2.6140633196001132e-06,2.532601936451969e-06,2.5690591195440147e-06,192 +dtmc,dense-n0025-s02718,dense,25,2718,evolution/k-100,1.059925030389305e-05,4.946389065773366e-07,1.0071943040513154e-05,1.1063378678496455e-05,1.0452079780517537e-05,1.0744276216610966e-05,162 +dtmc,dense-n0025-s02718,dense,25,2718,evolution/one-step,4.287975304566276e-07,7.854353567931087e-09,4.225372729803379e-07,4.405563865297062e-07,4.268519429657366e-07,4.305769249066434e-07,228 +dtmc,dense-n0025-s02718,dense,25,2718,finite-time/n-step/k-10,4.732598629036349e-06,2.529144642990125e-07,4.527735066234393e-06,5.174883010746843e-06,4.681871374783924e-06,4.85164989778247e-06,131 +dtmc,dense-n0025-s02718,dense,25,2718,finite-time/n-step/k-100,0.0001139808596793987,1.051260174815972e-05,0.00010354691580546715,0.0001264054608519042,0.00011072196251076933,0.00012010011938400567,91 +dtmc,dense-n0025-s02718,dense,25,2718,finite-time/observation/k-10,1.0328349464749329e-05,4.342801329959564e-06,8.30431171924499e-06,1.5549305214146853e-05,9.537395107397158e-06,1.387158166229104e-05,151 +dtmc,dense-n0025-s02718,dense,25,2718,finite-time/observation/k-100,2.677101742770223e-05,5.919606219904464e-07,2.6200317414797415e-05,2.7479777070299558e-05,2.657172381901557e-05,2.6970650026394115e-05,119 +dtmc,dense-n0025-s02718,dense,25,2718,finite-time/step,9.796797930390876e-07,7.518654706699135e-08,9.177920625554127e-07,1.0665582459904597e-06,9.623250662116335e-07,9.98728029492114e-07,185 +dtmc,dense-n0025-s02718,dense,25,2718,hitting-probability/cold-all-states,4.7904704541167954e-05,3.996485978198283e-07,4.7597871159361105e-05,4.94658328410102e-05,4.775354197260627e-05,4.8318756004639594e-05,108 +dtmc,dense-n0025-s02718,dense,25,2718,hitting-probability/warm-lookup,2.4370655107001463e-08,7.116283502949559e-10,2.3773311805872358e-08,2.7356609245255997e-08,2.4191771643207044e-08,2.492390908981295e-08,287 +dtmc,dense-n0025-s02718,dense,25,2718,hitting-time/cold-all-states,4.796401928895368e-05,2.0539773241710503e-06,4.5860044200471284e-05,4.991275471042533e-05,4.686566535383463e-05,4.8884085514834405e-05,107 +dtmc,dense-n0025-s02718,dense,25,2718,hitting-time/warm-lookup,2.5928818435379347e-08,1.050690024528836e-09,2.5157245094721508e-08,2.9674663573404527e-08,2.5700257626266162e-08,2.62753370605914e-08,286 +dtmc,dense-n0025-s02718,dense,25,2718,hitting/bounded/at-most/k-10,4.2803943503442644e-06,7.917033152536549e-08,4.226465894763308e-06,4.49426369634379e-06,4.248787290910541e-06,4.350668556677799e-06,155 +dtmc,dense-n0025-s02718,dense,25,2718,hitting/bounded/at-most/k-100,2.5589805078825778e-05,4.416941749007905e-07,2.5197561536391567e-05,2.665303316277288e-05,2.5313455483150965e-05,2.6022129214464848e-05,120 +dtmc,dense-n0025-s02718,dense,25,2718,hitting/bounded/exact/k-10,4.652383982099486e-06,3.770269640076372e-07,4.3182762207531295e-06,5.1716121302070025e-06,4.552736709696127e-06,4.828216633006163e-06,154 +dtmc,dense-n0025-s02718,dense,25,2718,hitting/bounded/exact/k-100,2.524546468204936e-05,1.6905014490475844e-07,2.5145041996034302e-05,2.6133766432719575e-05,2.5206836919491235e-05,2.5372840019898784e-05,120 +dtmc,dense-n0025-s02718,dense,25,2718,hitting/bounded/greater-than/k-10,4.500312982565149e-06,1.4186366802897635e-07,4.355844354785491e-06,4.64072075097062e-06,4.461937838431046e-06,4.525481253275993e-06,155 +dtmc,dense-n0025-s02718,dense,25,2718,hitting/bounded/greater-than/k-100,2.7041496650781482e-05,5.794899591310189e-07,2.6587408964029452e-05,2.8094111825445373e-05,2.689600619473589e-05,2.7283001691102983e-05,119 +dtmc,dense-n0025-s02718,dense,25,2718,power/10,1.9666747251141313e-05,9.894211263943565e-07,1.8572817673085427e-05,2.0537396048303826e-05,1.9365890663914903e-05,1.9946877853896063e-05,150 +dtmc,dense-n0025-s02718,dense,25,2718,power/100,2.6006967197221268e-05,1.5841258150282248e-06,2.4361246750221522e-05,2.7460093292032192e-05,2.5670128221670182e-05,2.633883490969585e-05,144 +dtmc,dense-n0025-s02718,dense,25,2718,power/2,1.5584677326372793e-05,4.5945390847318277e-07,1.5201904634654901e-05,1.625381534717519e-05,1.547111283575003e-05,1.5705166636810947e-05,155 +dtmc,dense-n0025-s02718,dense,25,2718,race/forward-committor,4.870902346799291e-05,1.2907278863419691e-06,4.7819895920952624e-05,5.14332630145536e-05,4.840563293934489e-05,4.995646382407618e-05,107 +dtmc,dense-n0025-s02718,dense,25,2718,return/bounded/k-10,4.23410665684516e-06,1.9280410724960648e-07,4.085927632791977e-06,4.599141179080744e-06,4.1735038394108415e-06,4.3116968946207935e-06,154 +dtmc,dense-n0025-s02718,dense,25,2718,return/bounded/k-100,3.0007091922634268e-05,8.623313637819433e-07,2.9488333522201945e-05,3.098114757449366e-05,2.984095437527016e-05,3.0507906298485716e-05,117 +dtmc,dense-n0025-s02718,dense,25,2718,return/mean-recurrence,2.995573200005807e-05,3.274959489956233e-06,2.7493295961635295e-05,3.915361101669849e-05,2.8955649169212258e-05,3.304018257164477e-05,117 +dtmc,dense-n0025-s02718,dense,25,2718,simulation/10000,0.008090642740410802,0.0004095972649782861,0.007914406360618563,0.00868510128514442,0.008021881599561312,0.008483416997478344,33 +dtmc,dense-n0025-s02718,dense,25,2718,simulation/100000,0.08258052330893406,0.0012988646338647145,0.08023840381065384,0.0836556423722262,0.07917757407267345,0.08387639491619275,10 +dtmc,dense-n0025-s02718,dense,25,2718,stationary,2.4471661890929527e-05,4.3673551316592524e-07,2.4137105961610318e-05,2.5392718675958304e-05,2.4318299256265164e-05,2.481596922870371e-05,120 +dtmc,dense-n0025-s02718,dense,25,2718,structure/classes-cold,1.2464895045566272e-05,1.1190853969779825e-06,1.170833841618615e-05,1.5491776738040326e-05,1.2042783719086408e-05,1.3079433007129718e-05,136 +dtmc,dense-n0025-s02718,dense,25,2718,structure/classes-lifecycle,5.697157479024048e-05,2.006625627787302e-06,5.51667160055201e-05,5.995938354329402e-05,5.652857274701785e-05,5.797949196430781e-05,129 +dtmc,dense-n0025-s02718,dense,25,2718,structure/classes-warm/access,8.681149798932725e-09,1.4729720091213871e-10,8.555267721339606e-09,1.0814220018562723e-08,8.61286019406297e-09,8.79498669294064e-09,309 +dtmc,dense-n0025-s02718,dense,25,2718,structure/classes-warm/consumed,1.065338684105309e-07,5.865004085114074e-10,1.0618836315327338e-07,1.1125946027302259e-07,1.0637138536292541e-07,1.0685230945079623e-07,257 +dtmc,dense-n0025-s02718,dense,25,2718,structure/irreducible-cold,8.65732208590141e-06,6.76788276052158e-08,8.604421052835267e-06,8.87022802739271e-06,8.629437434369961e-06,8.714519950741787e-06,141 +dtmc,dense-n0025-s02718,dense,25,2718,structure/irreducible-warm,1.046233457171533e-08,6.21816088365104e-10,1.0016652272177939e-08,1.3461529026524379e-08,1.0348731971576532e-08,1.060353758253684e-08,305 +dtmc,dense-n0025-s02718,dense,25,2718,visits/bounded-expectation/k-10,7.6229240625151025e-06,3.6637445566025136e-07,7.248148080085878e-06,7.965579673306987e-06,7.4910358004369e-06,7.743740297924918e-06,144 +dtmc,dense-n0025-s02718,dense,25,2718,visits/bounded-expectation/k-100,4.994923154000601e-05,4.7429913142483295e-07,4.9622551634219356e-05,5.0984726509671994e-05,4.9804437640604785e-05,5.0144999588564115e-05,113 +dtmc,dense-n0025-s31415,dense,25,31415,construction/public-consumed,3.899067555837837e-05,1.5393577480413078e-06,3.776510998475116e-05,4.2506169604409573e-05,3.871483873396926e-05,3.943943915714256e-05,134 +dtmc,dense-n0025-s31415,dense,25,31415,evolution/k-10,2.375000223024457e-06,4.981948623137202e-08,2.3378642235717977e-06,2.53313222568804e-06,2.3595164991936604e-06,2.4059807715320135e-06,190 +dtmc,dense-n0025-s31415,dense,25,31415,evolution/k-100,1.3840106911354034e-05,1.993788254015661e-06,1.1912406350077888e-05,1.595822939575742e-05,1.3031251000938937e-05,1.4384709730053155e-05,160 +dtmc,dense-n0025-s31415,dense,25,31415,evolution/one-step,4.222936972013092e-07,2.0286299022223153e-08,4.03750335735303e-07,4.567535462818661e-07,4.1894497625563763e-07,4.2747221111009525e-07,228 +dtmc,dense-n0025-s31415,dense,25,31415,finite-time/n-step/k-10,4.283468014500631e-06,2.962376450376412e-07,3.988396726456883e-06,4.580194828560857e-06,4.114670446142554e-06,4.368274639330041e-06,155 +dtmc,dense-n0025-s31415,dense,25,31415,finite-time/n-step/k-100,2.7843753494763455e-05,4.787516688165719e-07,2.7625522407402348e-05,2.8574053226750835e-05,2.770992513332102e-05,2.810687196547232e-05,118 +dtmc,dense-n0025-s31415,dense,25,31415,finite-time/observation/k-10,4.9519778748162714e-06,1.713223475216603e-07,4.78827477261228e-06,5.386877906893934e-06,4.8284720813829515e-06,5.03919826291691e-06,148 +dtmc,dense-n0025-s31415,dense,25,31415,finite-time/observation/k-100,2.922373855456143e-05,1.8780100384866618e-06,2.7776555721208952e-05,3.1141698127612474e-05,2.87903771487561e-05,3.0440488854202774e-05,117 +dtmc,dense-n0025-s31415,dense,25,31415,finite-time/step,8.795012295844831e-07,3.4671886948802094e-08,8.573249148354791e-07,9.755410624060599e-07,8.732897001288965e-07,8.937353614227894e-07,184 +dtmc,dense-n0025-s31415,dense,25,31415,hitting-probability/cold-all-states,5.849739776480149e-05,2.2527476500638327e-06,5.480360949162718e-05,6.028811486406495e-05,5.694236400795466e-05,5.913817803123167e-05,106 +dtmc,dense-n0025-s31415,dense,25,31415,hitting-probability/warm-lookup,2.556267863432656e-08,6.767638646980681e-10,2.492986445576931e-08,3.068859502115471e-08,2.5258756964931817e-08,2.6018587543312645e-08,285 +dtmc,dense-n0025-s31415,dense,25,31415,hitting-time/cold-all-states,5.3585766117683476e-05,2.5689002613971476e-06,5.119852892890134e-05,5.6459979755252754e-05,5.219466887259235e-05,5.460607845352256e-05,105 +dtmc,dense-n0025-s31415,dense,25,31415,hitting-time/warm-lookup,2.7533635715466105e-08,2.162285218606875e-09,2.7070028503520108e-08,3.120549323597357e-08,2.737790670175642e-08,2.777518438969195e-08,286 +dtmc,dense-n0025-s31415,dense,25,31415,hitting/bounded/at-most/k-10,5.9979167417623104e-06,3.1747315208324126e-07,5.694466138569017e-06,6.35990446074417e-06,5.920950934523717e-06,6.103505573768447e-06,149 +dtmc,dense-n0025-s31415,dense,25,31415,hitting/bounded/at-most/k-100,3.433080494065137e-05,1.4141924742123397e-06,3.2661529775856625e-05,3.559115242408723e-05,3.404810559004545e-05,3.4733397449005627e-05,115 +dtmc,dense-n0025-s31415,dense,25,31415,hitting/bounded/exact/k-10,5.49593334589458e-06,3.1624068615259556e-07,5.242533872076984e-06,5.918561015359114e-06,5.4205747294073495e-06,5.668067994217078e-06,149 +dtmc,dense-n0025-s31415,dense,25,31415,hitting/bounded/exact/k-100,3.465856834700243e-05,1.323749014783374e-06,3.36376775583732e-05,3.673301771735848e-05,3.409068104501076e-05,3.523823882209448e-05,114 +dtmc,dense-n0025-s31415,dense,25,31415,hitting/bounded/greater-than/k-10,5.636717625228422e-06,2.7849537651664364e-07,5.466477613306195e-06,6.11488882416614e-06,5.569908918829912e-06,5.762490752478323e-06,147 +dtmc,dense-n0025-s31415,dense,25,31415,hitting/bounded/greater-than/k-100,3.3713320735841986e-05,1.1717885111768976e-06,3.263731567445139e-05,3.4925997633470086e-05,3.3496353137804175e-05,3.400922179463561e-05,115 +dtmc,dense-n0025-s31415,dense,25,31415,power/10,1.819416647353325e-05,5.869074095862717e-07,1.7609185036875444e-05,1.8800586776233576e-05,1.8022519366817326e-05,1.838229818212424e-05,152 +dtmc,dense-n0025-s31415,dense,25,31415,power/100,2.184819329271016e-05,5.969112348469195e-07,2.138921126120496e-05,2.2694851292453234e-05,2.1682089481087165e-05,2.2108906791213253e-05,148 +dtmc,dense-n0025-s31415,dense,25,31415,power/2,1.5850749637337203e-05,1.1937733733049905e-06,1.4768939613025046e-05,1.706766478289881e-05,1.562710699792272e-05,1.6229183886986703e-05,154 +dtmc,dense-n0025-s31415,dense,25,31415,race/forward-committor,4.923310791325025e-05,1.0043368504249635e-06,4.8456359258529526e-05,5.363188533595103e-05,4.882502018613435e-05,5.040245998150733e-05,106 +dtmc,dense-n0025-s31415,dense,25,31415,return/bounded/k-10,5.155322688993862e-06,3.3668439424461425e-07,4.85400546570938e-06,5.556327475542367e-06,5.0716188746025466e-06,5.286702882865658e-06,152 +dtmc,dense-n0025-s31415,dense,25,31415,return/bounded/k-100,4.383156708291535e-05,8.981429644964741e-06,3.7316755029095905e-05,6.792370892068052e-05,4.109921218306011e-05,4.833897797983479e-05,111 +dtmc,dense-n0025-s31415,dense,25,31415,return/mean-recurrence,3.409352747870511e-05,1.4104432402239718e-06,3.258635743073754e-05,3.5481697165543273e-05,3.34301635584965e-05,3.4525086010369114e-05,113 +dtmc,dense-n0025-s31415,dense,25,31415,simulation/10000,0.00921474006249542,0.0003458921121337506,0.009111465904755856,0.010258491797139868,0.00912466650515853,0.009531950376185705,29 +dtmc,dense-n0025-s31415,dense,25,31415,simulation/100000,0.08857300874842622,0.001005656375127728,0.08799047216719676,0.08992334571000052,0.08794027770697235,0.08995950944598816,10 +dtmc,dense-n0025-s31415,dense,25,31415,stationary,2.9245785019692096e-05,1.3796969811330389e-06,2.804838446276595e-05,3.0873883802778216e-05,2.87430822452284e-05,2.9829723557451783e-05,112 +dtmc,dense-n0025-s31415,dense,25,31415,structure/classes-cold,1.3040172647746567e-05,1.3647030704340978e-06,1.1613659346097386e-05,1.4227440427706042e-05,1.2235555856603466e-05,1.3352073762276596e-05,130 +dtmc,dense-n0025-s31415,dense,25,31415,structure/classes-lifecycle,5.485268806088966e-05,9.40175070628863e-07,5.3954318758237815e-05,5.590654114768193e-05,5.4334849265915695e-05,5.5221593583100165e-05,128 +dtmc,dense-n0025-s31415,dense,25,31415,structure/classes-warm/access,1.1043340846508001e-08,6.372099213594289e-10,1.0530630814517038e-08,1.360186007288005e-08,1.0881430244379103e-08,1.1243500267686063e-08,304 +dtmc,dense-n0025-s31415,dense,25,31415,structure/classes-warm/consumed,1.4203343314508348e-07,3.236842058679346e-09,1.3952679308643338e-07,1.521111698821187e-07,1.4100695718876364e-07,1.4332723959747424e-07,253 +dtmc,dense-n0025-s31415,dense,25,31415,structure/irreducible-cold,1.1926773600040578e-05,6.430233471337504e-07,1.1170850720030584e-05,1.2512683487339916e-05,1.1805854298076118e-05,1.2054373354827405e-05,136 +dtmc,dense-n0025-s31415,dense,25,31415,structure/irreducible-warm,1.1293163265815532e-08,5.855725264317579e-10,1.0897675525628754e-08,1.409407243919126e-08,1.1142621686566361e-08,1.1514209718500439e-08,302 +dtmc,dense-n0025-s31415,dense,25,31415,visits/bounded-expectation/k-10,8.786586655426165e-06,4.1995727805280365e-07,8.372890479839013e-06,9.302554880613806e-06,8.559711104780844e-06,8.93100372958352e-06,141 +dtmc,dense-n0025-s31415,dense,25,31415,visits/bounded-expectation/k-100,5.945573777491921e-05,1.3817889207596146e-06,5.8265739527815855e-05,6.122731138346738e-05,5.906940945847468e-05,5.985779395867961e-05,110 +dtmc,dense-n0050-s01729,dense,50,1729,construction/public-consumed,0.00018430514704531934,1.4385922413555807e-05,0.0001691023475754976,0.00019151261841694544,0.00017593056642605613,0.00018725889437999366,103 +dtmc,dense-n0050-s01729,dense,50,1729,evolution/k-10,5.711939533344716e-06,3.1129261855000136e-07,5.4962925075106866e-06,6.163547886633561e-06,5.627909388250145e-06,5.907747633657163e-06,174 +dtmc,dense-n0050-s01729,dense,50,1729,evolution/k-100,2.8625860799478424e-05,1.8758608385939723e-06,2.6727226684869152e-05,3.0413999939487587e-05,2.8251591776209474e-05,2.9117571622399347e-05,141 +dtmc,dense-n0050-s01729,dense,50,1729,evolution/one-step,9.545454469678754e-07,2.904562279582013e-08,9.27129930401474e-07,9.938257351406869e-07,9.493345837217371e-07,9.58953843827761e-07,211 +dtmc,dense-n0050-s01729,dense,50,1729,finite-time/n-step/k-10,7.852899622954407e-06,7.965192578890117e-07,6.838398803665768e-06,8.472605333782924e-06,7.449450917885683e-06,8.160745658512627e-06,144 +dtmc,dense-n0050-s01729,dense,50,1729,finite-time/n-step/k-100,5.8468332898690164e-05,2.5408679512667595e-06,5.5163800712588736e-05,6.049672410472851e-05,5.780441642855294e-05,5.919725490611646e-05,103 +dtmc,dense-n0050-s01729,dense,50,1729,finite-time/observation/k-10,9.487821337054757e-06,8.451784139170372e-07,8.323965364815132e-06,1.0159432903215613e-05,9.316859571766611e-06,9.700868426815406e-06,141 +dtmc,dense-n0050-s01729,dense,50,1729,finite-time/observation/k-100,6.25667713716339e-05,2.0877619580933227e-06,6.09164999332279e-05,6.517542871214184e-05,6.17552965413779e-05,6.306868453975767e-05,101 +dtmc,dense-n0050-s01729,dense,50,1729,finite-time/step,1.4580873933879533e-06,1.4739094551374257e-07,1.3117039131032645e-06,1.6037641688846457e-06,1.4218286855803438e-06,1.4923741610034083e-06,180 +dtmc,dense-n0050-s01729,dense,50,1729,hitting-probability/cold-all-states,0.00014636684428478712,1.712524818924701e-06,0.00014526481891451238,0.00014873822358042938,0.0001460001852212257,0.00014686100378942987,82 +dtmc,dense-n0050-s01729,dense,50,1729,hitting-probability/warm-lookup,2.5465436598303486e-08,6.301119141707328e-10,2.491327802721062e-08,2.934592827037313e-08,2.5167518814499106e-08,2.587365216316924e-08,285 +dtmc,dense-n0050-s01729,dense,50,1729,hitting-time/cold-all-states,0.00016164574896850224,7.4485524898038665e-06,0.00015381052302660108,0.00016860991044350985,0.00015693750174250454,0.00016629100719001144,81 +dtmc,dense-n0050-s01729,dense,50,1729,hitting-time/warm-lookup,3.0051712107298703e-08,2.075288962872428e-09,2.8312079613262608e-08,3.309299243484361e-08,2.9670832383033504e-08,3.050018883009009e-08,283 +dtmc,dense-n0050-s01729,dense,50,1729,hitting/bounded/at-most/k-10,7.224931808498998e-06,3.694118628086389e-07,6.9164717210236974e-06,8.680458197184042e-06,7.045732240467408e-06,7.4902112062677345e-06,139 +dtmc,dense-n0050-s01729,dense,50,1729,hitting/bounded/at-most/k-100,6.324480690255983e-05,2.1954890375682485e-06,6.12698041246169e-05,6.545985814336363e-05,6.276164652488971e-05,6.402912849297519e-05,102 +dtmc,dense-n0050-s01729,dense,50,1729,hitting/bounded/exact/k-10,1.105485981552457e-05,1.6230505094235085e-06,9.414019278099076e-06,1.2612638764697663e-05,1.0102424350103926e-05,1.168096880428493e-05,141 +dtmc,dense-n0050-s01729,dense,50,1729,hitting/bounded/exact/k-100,5.5348738035383193e-05,2.205742274526109e-06,5.337762939589815e-05,5.773490189731253e-05,5.3931116081702596e-05,5.618124766666712e-05,105 +dtmc,dense-n0050-s01729,dense,50,1729,hitting/bounded/greater-than/k-10,9.040981093718227e-06,8.077876757097158e-07,8.236114365545426e-06,9.849454100450952e-06,8.816901150539906e-06,9.22836749707226e-06,142 +dtmc,dense-n0050-s01729,dense,50,1729,hitting/bounded/greater-than/k-100,6.363256410565812e-05,1.6272094951746155e-06,6.2455623265123e-05,6.565221765017866e-05,6.30575959520975e-05,6.408292477187518e-05,101 +dtmc,dense-n0050-s01729,dense,50,1729,power/10,6.21651579516061e-05,3.8643997048192126e-06,5.83259928067211e-05,6.599236990670518e-05,6.061786056064419e-05,6.338956861208337e-05,126 +dtmc,dense-n0050-s01729,dense,50,1729,power/100,8.02583332794408e-05,4.252833349981523e-06,7.591466696578122e-05,8.41769463729826e-05,7.834923671352329e-05,8.129829600349897e-05,121 +dtmc,dense-n0050-s01729,dense,50,1729,power/2,5.030942029670637e-05,1.8018639360683879e-06,4.906109007403509e-05,5.2610447308649484e-05,4.988263588695025e-05,5.10810546832848e-05,131 +dtmc,dense-n0050-s01729,dense,50,1729,race/forward-committor,0.0001606166810704992,1.1109783928178426e-05,0.000150405260051013,0.0001730871018376726,0.00015651916210158976,0.00016701119966455735,78 +dtmc,dense-n0050-s01729,dense,50,1729,return/bounded/k-10,8.92211912585898e-06,7.060293099561054e-07,8.397921587539075e-06,9.88534682678179e-06,8.778183104226503e-06,9.3039998319e-06,142 +dtmc,dense-n0050-s01729,dense,50,1729,return/bounded/k-100,5.63787011503193e-05,1.8375282123510046e-06,5.476243154794452e-05,5.818341086852874e-05,5.592754781494142e-05,5.711571459553908e-05,103 +dtmc,dense-n0050-s01729,dense,50,1729,return/mean-recurrence,0.00012750693533537615,8.086663162163696e-06,0.00012032400356433375,0.00013715658961332508,0.00012480307878621927,0.0001303670634525178,82 +dtmc,dense-n0050-s01729,dense,50,1729,simulation/10000,0.009123635349678806,0.00036245978273135356,0.008702369360876868,0.00941080468848148,0.008958324033301324,0.009291654037672112,32 +dtmc,dense-n0050-s01729,dense,50,1729,simulation/100000,0.08441528143424269,0.0006282414507979214,0.08392321909071013,0.08545721874179435,0.08387163085405648,0.08566662498924416,10 +dtmc,dense-n0050-s01729,dense,50,1729,stationary,0.00011872573425838102,5.165373213098537e-06,0.00011289712358458141,0.0001230102350577188,0.00011625876246296548,0.00012113757530283748,89 +dtmc,dense-n0050-s01729,dense,50,1729,structure/classes-cold,4.648328764790522e-05,2.2244426521559925e-06,4.4635702587581256e-05,4.926948266594471e-05,4.5876796922145285e-05,4.778695342777862e-05,104 +dtmc,dense-n0050-s01729,dense,50,1729,structure/classes-lifecycle,0.00028454545464893816,7.820545480573e-06,0.00027654527486265683,0.0002921682279632302,0.00028130245058312375,0.0002863665818880095,96 +dtmc,dense-n0050-s01729,dense,50,1729,structure/classes-warm/access,1.3596556880374852e-08,1.1983051742524813e-09,1.281450120057641e-08,1.7822577725853156e-08,1.3372531804948882e-08,1.3831180425306429e-08,302 +dtmc,dense-n0050-s01729,dense,50,1729,structure/classes-warm/consumed,2.995791275472722e-07,1.2572469388467966e-08,2.8981874187073586e-07,3.178976345245432e-07,2.9764353894683474e-07,3.0263158566269437e-07,235 +dtmc,dense-n0050-s01729,dense,50,1729,structure/irreducible-cold,3.681224916363135e-05,1.9914470613002804e-06,3.4667119538939875e-05,3.850644900108149e-05,3.595775036190293e-05,3.718654336107616e-05,113 +dtmc,dense-n0050-s01729,dense,50,1729,structure/irreducible-warm,1.1149958284657868e-08,1.0664234441138394e-09,1.0139830000194171e-08,1.3688558830792418e-08,1.1013896063233445e-08,1.1288621099143065e-08,304 +dtmc,dense-n0050-s01729,dense,50,1729,visits/bounded-expectation/k-10,1.166353014314934e-05,4.886518193837744e-07,1.1198353932842212e-05,1.2156106204666027e-05,1.1567613956158465e-05,1.179874949334154e-05,134 +dtmc,dense-n0050-s01729,dense,50,1729,visits/bounded-expectation/k-100,8.095967340133419e-05,3.129972421493348e-06,7.790423996327389e-05,8.407016936734301e-05,8.00095045373642e-05,8.166261989298085e-05,94 +dtmc,dense-n0050-s02718,dense,50,2718,construction/public-consumed,0.00016119217349225845,1.0220229947706893e-05,0.00015250772223764756,0.00017429125032362031,0.00015526024799328297,0.000170679051458003,105 +dtmc,dense-n0050-s02718,dense,50,2718,evolution/k-10,6.7641275773684565e-06,3.46750384169118e-07,6.493347304770431e-06,7.279671948623612e-06,6.68150437274888e-06,6.878920108400546e-06,174 +dtmc,dense-n0050-s02718,dense,50,2718,evolution/k-100,2.490299812052399e-05,1.6613672737676254e-06,2.328763215336949e-05,2.7076452066534763e-05,2.364039845406955e-05,2.5468611916811256e-05,143 +dtmc,dense-n0050-s02718,dense,50,2718,evolution/one-step,8.792668861024558e-07,2.3879788303793023e-08,8.618576940100029e-07,9.362204131814877e-07,8.722418422765841e-07,8.918512785965774e-07,212 +dtmc,dense-n0050-s02718,dense,50,2718,finite-time/n-step/k-10,7.021666386389448e-06,5.24912203605638e-07,6.355030237017196e-06,7.499377881576825e-06,6.805122621323121e-06,7.194289393833299e-06,143 +dtmc,dense-n0050-s02718,dense,50,2718,finite-time/n-step/k-100,5.371484687563336e-05,4.705648064303525e-06,4.8422954751003997e-05,5.746551664850893e-05,5.21267686050399e-05,5.540598779298827e-05,104 +dtmc,dense-n0050-s02718,dense,50,2718,finite-time/observation/k-10,9.660282818464539e-06,8.762065506863275e-07,8.743571848395592e-06,1.0474231401510704e-05,9.33524216879724e-06,9.903699581234439e-06,141 +dtmc,dense-n0050-s02718,dense,50,2718,finite-time/observation/k-100,5.089428799692541e-05,2.1091806028332354e-06,4.859893529383267e-05,5.243717469201083e-05,4.9696168868222784e-05,5.1427048310870306e-05,103 +dtmc,dense-n0050-s02718,dense,50,2718,finite-time/step,1.5222396458108548e-06,9.074466090817204e-08,1.428775169846619e-06,1.609663934190587e-06,1.504998654127121e-06,1.5395212038026624e-06,179 +dtmc,dense-n0050-s02718,dense,50,2718,hitting-probability/cold-all-states,0.00015148139253471634,4.087268081050187e-06,0.0001467422272776718,0.00015499598521273583,0.00014863158256738908,0.00015407904677638065,82 +dtmc,dense-n0050-s02718,dense,50,2718,hitting-probability/warm-lookup,2.8104358901332848e-08,2.1901062215112777e-09,2.6837211772613677e-08,3.179352157544148e-08,2.7710049690550145e-08,2.862199864474648e-08,284 +dtmc,dense-n0050-s02718,dense,50,2718,hitting-time/cold-all-states,0.00017101703512404737,9.81240045803134e-06,0.00016172249756242049,0.00018113734692054676,0.00016554811255962802,0.00017692860394947954,76 +dtmc,dense-n0050-s02718,dense,50,2718,hitting-time/warm-lookup,3.5744464351878776e-08,3.2974270893465475e-09,3.309175600092929e-08,4.125503537373773e-08,3.504996580410705e-08,3.628928045169921e-08,282 +dtmc,dense-n0050-s02718,dense,50,2718,hitting/bounded/at-most/k-10,8.494181085248268e-06,6.505988770395067e-07,7.913308927894686e-06,9.287805122327644e-06,8.347513083251646e-06,8.579373523713736e-06,144 +dtmc,dense-n0050-s02718,dense,50,2718,hitting/bounded/at-most/k-100,5.062348079971141e-05,1.6793659562020099e-06,4.868685708580805e-05,5.2233402661755155e-05,4.969938949979309e-05,5.1275857480331544e-05,105 +dtmc,dense-n0050-s02718,dense,50,2718,hitting/bounded/exact/k-10,8.450978497053717e-06,7.7049206235429e-07,7.69441612646915e-06,9.221470559408007e-06,8.12243979453342e-06,8.858768236263408e-06,145 +dtmc,dense-n0050-s02718,dense,50,2718,hitting/bounded/exact/k-100,4.951449400842393e-05,1.3106369555078887e-06,4.820385705291604e-05,5.062127725432937e-05,4.907053796789394e-05,4.988881912557563e-05,105 +dtmc,dense-n0050-s02718,dense,50,2718,hitting/bounded/greater-than/k-10,7.89684236224275e-06,5.829375887904981e-07,7.457922590986652e-06,8.853828718914238e-06,7.664113629428193e-06,8.314073460900949e-06,140 +dtmc,dense-n0050-s02718,dense,50,2718,hitting/bounded/greater-than/k-100,5.609096099172294e-05,3.1177259820037484e-06,5.0208875564623656e-05,5.787627190989488e-05,5.56357882680569e-05,5.649358621493149e-05,104 +dtmc,dense-n0050-s02718,dense,50,2718,power/10,5.607555633307331e-05,5.801583408393062e-06,5.051836528620003e-05,6.243112920318602e-05,5.3767385644699255e-05,5.7597673639571036e-05,130 +dtmc,dense-n0050-s02718,dense,50,2718,power/100,7.642254801128676e-05,1.4042405086896602e-05,6.18767720273657e-05,8.928939793549812e-05,6.762578830899973e-05,7.992253766855228e-05,118 +dtmc,dense-n0050-s02718,dense,50,2718,power/2,4.506542985308833e-05,1.5044761883161493e-06,4.332560867771357e-05,4.618250908754525e-05,4.446017156428128e-05,4.593679644001115e-05,134 +dtmc,dense-n0050-s02718,dense,50,2718,race/forward-committor,0.00017606110251769857,8.02453754579034e-06,0.00016861107774400667,0.00018638430382062713,0.00017201515269921227,0.00018080268254332048,80 +dtmc,dense-n0050-s02718,dense,50,2718,return/bounded/k-10,7.972286075067743e-06,6.571271909641215e-07,7.336760359442033e-06,8.710750805901921e-06,7.80203441646401e-06,8.12467139136667e-06,148 +dtmc,dense-n0050-s02718,dense,50,2718,return/bounded/k-100,4.4944176208337325e-05,1.051520849840004e-07,4.4881725124788e-05,4.515157132513131e-05,4.4915515650944435e-05,4.499499943146172e-05,108 +dtmc,dense-n0050-s02718,dense,50,2718,return/mean-recurrence,0.00011138527496360189,3.8036193970929325e-06,0.00010817566524363226,0.00011818778175784016,0.00011008118167080903,0.00011318149384016196,85 +dtmc,dense-n0050-s02718,dense,50,2718,simulation/10000,0.006618808605258883,2.703615975298019e-05,0.006586943494605496,0.00664136198356573,0.00659527099924162,0.006634753800770138,36 +dtmc,dense-n0050-s02718,dense,50,2718,simulation/100000,0.06646458333125338,0.00011181283480254933,0.06635064233099305,0.06650183977118493,0.06634851416553526,0.06651411314253762,11 +dtmc,dense-n0050-s02718,dense,50,2718,stationary,0.00012645109446548,9.658222769947706e-06,0.00011916929347519584,0.00013827156690240374,0.00012396877536957618,0.00013040275088213902,87 +dtmc,dense-n0050-s02718,dense,50,2718,structure/classes-cold,4.489662748006972e-05,2.407959281811889e-06,4.282154866096684e-05,4.777322938004952e-05,4.3986146314030826e-05,4.5993062087904125e-05,107 +dtmc,dense-n0050-s02718,dense,50,2718,structure/classes-lifecycle,0.0002742121363222726,2.4303044814256622e-05,0.0002502552779305294,0.0003004800936122371,0.00026193900602408237,0.00028704785196438296,95 +dtmc,dense-n0050-s02718,dense,50,2718,structure/classes-warm/access,1.211913892682775e-08,8.601751892540904e-10,1.1429062503632297e-08,1.5280596064524452e-08,1.1885576073314935e-08,1.241551997921755e-08,304 +dtmc,dense-n0050-s02718,dense,50,2718,structure/classes-warm/consumed,3.225370029987836e-07,1.7287219160611094e-08,3.090488579550467e-07,3.4832244614591563e-07,3.200790100722104e-07,3.250332406815816e-07,237 +dtmc,dense-n0050-s02718,dense,50,2718,structure/irreducible-cold,3.739497601144471e-05,1.3237089090876355e-06,3.6097384294689404e-05,3.8767696474249275e-05,3.6951342226529964e-05,3.787888103144542e-05,110 +dtmc,dense-n0050-s02718,dense,50,2718,structure/irreducible-warm,1.2810277799923788e-08,1.2855719750325226e-09,1.1873449588869028e-08,1.6245337162143403e-08,1.2555639022719871e-08,1.305356758449774e-08,301 +dtmc,dense-n0050-s02718,dense,50,2718,visits/bounded-expectation/k-10,8.385626600042564e-06,3.37740398655033e-08,8.351332674934823e-06,8.41923435066031e-06,8.373383742251706e-06,8.399821056697805e-06,142 +dtmc,dense-n0050-s02718,dense,50,2718,visits/bounded-expectation/k-100,6.420480057838266e-05,1.1055921861597795e-07,6.41052139278866e-05,6.43570836832645e-05,6.4169398548849e-05,6.425220539715569e-05,100 +dtmc,dense-n0050-s31415,dense,50,31415,construction/public-consumed,0.00015445975179978862,2.939909948530974e-06,0.0001520149827548586,0.00015774031512245045,0.0001539753262501722,0.00015582956496150503,108 +dtmc,dense-n0050-s31415,dense,50,31415,evolution/k-10,4.803284669468137e-06,1.0199126951724959e-07,4.717548014714769e-06,4.9620861115007265e-06,4.781135875997479e-06,4.834434213606935e-06,179 +dtmc,dense-n0050-s31415,dense,50,31415,evolution/k-100,2.2967192709857466e-05,6.97384925525726e-07,2.226063816124224e-05,2.3651733524406825e-05,2.2682889215906875e-05,2.3091995842723862e-05,147 +dtmc,dense-n0050-s31415,dense,50,31415,evolution/one-step,8.1804998141403e-07,2.0339982092390036e-08,8.009666322417626e-07,8.466289947856027e-07,8.123409328344342e-07,8.23242413444501e-07,215 +dtmc,dense-n0050-s31415,dense,50,31415,finite-time/n-step/k-10,7.142905353085184e-06,5.527722009415542e-07,6.4814680966623205e-06,7.578885114842672e-06,6.844425045598585e-06,7.255217359511636e-06,146 +dtmc,dense-n0050-s31415,dense,50,31415,finite-time/n-step/k-100,4.850113206073847e-05,1.1352287194107359e-06,4.729489256723403e-05,4.9419990483827514e-05,4.8111920176209874e-05,4.8750828777945976e-05,106 +dtmc,dense-n0050-s31415,dense,50,31415,finite-time/observation/k-10,8.616821244422098e-06,3.562654582034388e-07,8.17199150056373e-06,8.911025985697914e-06,8.451332784413049e-06,8.658722397477755e-06,142 +dtmc,dense-n0050-s31415,dense,50,31415,finite-time/observation/k-100,4.739014239087974e-05,1.3211509976085307e-06,4.587902347549327e-05,4.859291562820332e-05,4.692410045894764e-05,4.7734666683633504e-05,107 +dtmc,dense-n0050-s31415,dense,50,31415,finite-time/step,1.1664096036918954e-06,9.934454227210346e-08,1.079565542020796e-06,1.311971182557894e-06,1.1416702768621832e-06,1.2038380946590701e-06,182 +dtmc,dense-n0050-s31415,dense,50,31415,hitting-probability/cold-all-states,0.00015595542884684047,5.893535040247044e-06,0.00015006171423888662,0.00016162241009672133,0.00015451931550227246,0.00015843116507620818,82 +dtmc,dense-n0050-s31415,dense,50,31415,hitting-probability/warm-lookup,2.602220445401938e-08,9.741278002631298e-10,2.5190324413947708e-08,2.9197858793535334e-08,2.5799422777955068e-08,2.621727132681358e-08,286 +dtmc,dense-n0050-s31415,dense,50,31415,hitting-time/cold-all-states,0.00015549425973091857,3.562584260201015e-06,0.0001525771002399359,0.00015977356856510428,0.00015437175962388294,0.00015687554911659318,82 +dtmc,dense-n0050-s31415,dense,50,31415,hitting-time/warm-lookup,2.6547704248812744e-08,1.3101025871784104e-09,2.5525279401966954e-08,3.1250014568254224e-08,2.6154744024455234e-08,2.6900674583641887e-08,286 +dtmc,dense-n0050-s31415,dense,50,31415,hitting/bounded/at-most/k-10,8.769152862861609e-06,8.996245352922844e-07,8.12355680783593e-06,1.0682375095375056e-05,8.493643256253274e-06,9.186067230378587e-06,143 +dtmc,dense-n0050-s31415,dense,50,31415,hitting/bounded/at-most/k-100,4.98523721725643e-05,2.502108292597248e-06,4.709099888596909e-05,5.2038420850152245e-05,4.8603228159266926e-05,5.1117590320406156e-05,104 +dtmc,dense-n0050-s31415,dense,50,31415,hitting/bounded/exact/k-10,6.904005260235563e-06,1.6798600716791378e-07,6.766112294061947e-06,7.371517373636986e-06,6.851424546541432e-06,6.993378190310213e-06,143 +dtmc,dense-n0050-s31415,dense,50,31415,hitting/bounded/exact/k-100,5.033282078719432e-05,1.5780135556029605e-06,4.870833072345704e-05,5.183370411396027e-05,4.978030285036022e-05,5.077977174161268e-05,105 +dtmc,dense-n0050-s31415,dense,50,31415,hitting/bounded/greater-than/k-10,8.515586387781131e-06,4.59533175038469e-07,8.03072438015355e-06,8.959070168713337e-06,8.351330591627788e-06,8.637500286567956e-06,141 +dtmc,dense-n0050-s31415,dense,50,31415,hitting/bounded/greater-than/k-100,4.8947513896711776e-05,1.2558462547877357e-06,4.7256166840319144e-05,5.0004629883915186e-05,4.839390616821633e-05,4.923649704889269e-05,105 +dtmc,dense-n0050-s31415,dense,50,31415,power/10,5.720762553560712e-05,2.7941274929889993e-06,5.493945128126889e-05,6.095742875045577e-05,5.63322014760856e-05,5.818858727881723e-05,128 +dtmc,dense-n0050-s31415,dense,50,31415,power/100,6.796414648530433e-05,3.3285747623017033e-06,6.484372057290778e-05,7.177256063941784e-05,6.698356500321981e-05,6.948511197785702e-05,124 +dtmc,dense-n0050-s31415,dense,50,31415,power/2,4.5052083199455715e-05,1.6505035856043617e-06,4.349813207227271e-05,4.671874921768904e-05,4.476185755005905e-05,4.559292238599692e-05,133 +dtmc,dense-n0050-s31415,dense,50,31415,race/forward-committor,0.00015187966831338903,4.693163888684149e-06,0.0001486456923153099,0.00015799492437949857,0.0001508001825191401,0.00015415627549373312,81 +dtmc,dense-n0050-s31415,dense,50,31415,return/bounded/k-10,6.1605427465263196e-06,2.1642247315239674e-07,5.99944864266685e-06,6.674343856205229e-06,6.1283844690484434e-06,6.20832908627333e-06,144 +dtmc,dense-n0050-s31415,dense,50,31415,return/bounded/k-100,4.989321100498166e-05,3.0907885125059056e-06,4.7167374694554705e-05,5.339771499308105e-05,4.8999667948616356e-05,5.086584228400835e-05,103 +dtmc,dense-n0050-s31415,dense,50,31415,return/mean-recurrence,0.00010761076448656752,2.997647970914838e-06,0.00010543162430270999,0.00011145219858425206,0.00010711235736215343,0.0001092986957767067,90 +dtmc,dense-n0050-s31415,dense,50,31415,simulation/10000,0.007412283714025162,0.0002568611322141083,0.007171168504373782,0.007670355057388616,0.007203151120847906,0.0076046572587895956,34 +dtmc,dense-n0050-s31415,dense,50,31415,simulation/100000,0.08380987276866238,0.003239663731099948,0.07810810387935715,0.08652114149754198,0.07629415850533405,0.08685407299708459,10 +dtmc,dense-n0050-s31415,dense,50,31415,stationary,0.00010668167139979242,2.7046121444630555e-06,0.00010395505697272952,0.00010921811204949532,0.00010615333754546232,0.0001079627529199999,90 +dtmc,dense-n0050-s31415,dense,50,31415,structure/classes-cold,3.7398877977635306e-05,1.483800078502774e-06,3.624422217890284e-05,4.009077179433549e-05,3.709195549929159e-05,3.884446005765346e-05,110 +dtmc,dense-n0050-s31415,dense,50,31415,structure/classes-lifecycle,0.00022451563290480729,7.138311659466936e-06,0.00021722708006564065,0.00023140337356569003,0.00022062003432774286,0.00022757666971271996,100 +dtmc,dense-n0050-s31415,dense,50,31415,structure/classes-warm/access,9.407355708830064e-09,4.307784640345058e-10,9.126236344395051e-09,1.1963106917140974e-08,9.348273920241667e-09,9.536386746985569e-09,307 +dtmc,dense-n0050-s31415,dense,50,31415,structure/classes-warm/consumed,2.5359543989964997e-07,8.4950067031663e-09,2.460564699815663e-07,2.6548126461291224e-07,2.517107941743821e-07,2.5515790475969626e-07,240 +dtmc,dense-n0050-s31415,dense,50,31415,structure/irreducible-cold,3.054446788155474e-05,4.696288669947555e-07,3.0160230180755976e-05,3.144229025696332e-05,3.0312501101954175e-05,3.0849703078567604e-05,115 +dtmc,dense-n0050-s31415,dense,50,31415,structure/irreducible-warm,1.0166442463322287e-08,5.930465828125408e-10,9.690846987706713e-09,1.2402508301937587e-08,9.991016973280083e-09,1.0331275938998587e-08,305 +dtmc,dense-n0050-s31415,dense,50,31415,visits/bounded-expectation/k-10,1.11692131736852e-05,7.39898858251032e-07,1.0479053885976833e-05,1.195949966801747e-05,1.0976513685362902e-05,1.1399998766137286e-05,137 +dtmc,dense-n0050-s31415,dense,50,31415,visits/bounded-expectation/k-100,6.73799999832025e-05,6.700029907897638e-07,6.66944752580696e-05,6.800517565707928e-05,6.711728852487316e-05,6.757414792790204e-05,99 +dtmc,dense-n0100-s01729,dense,100,1729,construction/public-consumed,0.0006354350490237623,1.925738610237084e-05,0.0006171012347434813,0.0006583199367014459,0.000626068989281863,0.0006419795026886277,79 +dtmc,dense-n0100-s01729,dense,100,1729,evolution/k-10,1.2551100356607643e-05,9.446002929469846e-07,1.1668074997335982e-05,1.367604955051437e-05,1.2140330991729278e-05,1.2917842666904015e-05,159 +dtmc,dense-n0100-s01729,dense,100,1729,evolution/k-100,0.00011566154655341406,3.53734667711806e-06,0.00011240823802100273,0.00012035767866293324,0.00011455657139387248,0.00011670672483277357,113 +dtmc,dense-n0100-s01729,dense,100,1729,evolution/one-step,1.7887292349092967e-06,5.468679131664053e-08,1.731771943822322e-06,1.8421216237006922e-06,1.7715318967594497e-06,1.8026698968436533e-06,199 +dtmc,dense-n0100-s01729,dense,100,1729,finite-time/n-step/k-10,1.8473388601185953e-05,1.3123154709869938e-06,1.66729736286964e-05,1.9630491623190864e-05,1.8166690446937886e-05,1.8770995666272938e-05,125 +dtmc,dense-n0100-s01729,dense,100,1729,finite-time/n-step/k-100,0.00012495803381607282,6.012203572488886e-06,0.00011969229221535289,0.00013125564011837542,0.00012316571253995283,0.00012776127717224075,88 +dtmc,dense-n0100-s01729,dense,100,1729,finite-time/observation/k-10,2.315217775437792e-05,1.7645330234605935e-06,2.1453013013390705e-05,2.5260600031705927e-05,2.2707104981949953e-05,2.380921183717682e-05,121 +dtmc,dense-n0100-s01729,dense,100,1729,finite-time/observation/k-100,0.00012713195397744045,6.7959054349798185e-06,0.00012249578142194516,0.00013545883380824568,0.00012452705840882116,0.00013214567968920234,88 +dtmc,dense-n0100-s01729,dense,100,1729,finite-time/step,2.078860248645179e-06,2.6762660403682067e-07,1.692961707400779e-06,2.303427730142819e-06,2.0018809568419116e-06,2.1516356466605347e-06,169 +dtmc,dense-n0100-s01729,dense,100,1729,hitting-probability/cold-all-states,0.000590567306901973,1.9466129023195332e-05,0.0005748758979434302,0.0006145911389187724,0.0005828471819933674,0.0006050979908549278,55 +dtmc,dense-n0100-s01729,dense,100,1729,hitting-probability/warm-lookup,2.986177124137826e-08,1.0323832684292957e-09,2.9046310587843102e-08,3.353672011346407e-08,2.9566846862513166e-08,3.0333763686022214e-08,283 +dtmc,dense-n0100-s01729,dense,100,1729,hitting-time/cold-all-states,0.0005833526139702791,3.2539420721303656e-05,0.000553559961845167,0.0006368807034133087,0.0005709133855326889,0.0006023698987686361,53 +dtmc,dense-n0100-s01729,dense,100,1729,hitting-time/warm-lookup,2.8037561610483315e-08,2.6266569235667437e-09,2.5841968001360186e-08,3.176794187754859e-08,2.7692338326433484e-08,2.8354710402049765e-08,286 +dtmc,dense-n0100-s01729,dense,100,1729,hitting/bounded/at-most/k-10,2.451664913678542e-05,1.4268031482559255e-06,2.288125268110196e-05,2.5490540164359973e-05,2.4129957951661615e-05,2.48090759094549e-05,119 +dtmc,dense-n0100-s01729,dense,100,1729,hitting/bounded/at-most/k-100,0.00014346870739245787,5.494930911552459e-06,0.00013932562220887753,0.0001504318820939823,0.0001421862927383121,0.00014626744141530104,84 +dtmc,dense-n0100-s01729,dense,100,1729,hitting/bounded/exact/k-10,2.3360174108187066e-05,3.303175114681875e-06,1.8417016515362296e-05,2.5080618224414733e-05,2.1891550848911198e-05,2.399658078671382e-05,119 +dtmc,dense-n0100-s01729,dense,100,1729,hitting/bounded/exact/k-100,0.00012860337813201892,8.7525960980057e-06,0.00011976424753407223,0.00013636182639889372,0.0001237008705370442,0.00013253723648775026,84 +dtmc,dense-n0100-s01729,dense,100,1729,hitting/bounded/greater-than/k-10,2.36152339008792e-05,1.6865913200829973e-06,2.206889534347809e-05,2.566275846523543e-05,2.319603744480345e-05,2.4238743650113345e-05,121 +dtmc,dense-n0100-s01729,dense,100,1729,hitting/bounded/greater-than/k-100,0.00014162380652895523,1.0557148771738703e-05,0.00012905079843744636,0.00015027321147489437,0.00013432371292765647,0.00014473234878096264,86 +dtmc,dense-n0100-s01729,dense,100,1729,power/10,0.00019897401274102604,9.658888035126535e-06,0.0001894035417058654,0.00020870063072786607,0.00019429532912142218,0.00020268774153847833,102 +dtmc,dense-n0100-s01729,dense,100,1729,power/100,0.00023966925328289588,3.0198595514046642e-05,0.00021381786914894798,0.0002981639690674677,0.000222187041634408,0.0002729114124864881,94 +dtmc,dense-n0100-s01729,dense,100,1729,power/2,0.00015275404860177086,7.84477399567662e-06,0.0001470632946492294,0.00016105895767754523,0.00015044967645215762,0.00015534394779210235,108 +dtmc,dense-n0100-s01729,dense,100,1729,race/forward-committor,0.0004732497710274006,1.8233651775377715e-05,0.0004510951510096843,0.00048422707948138084,0.00046193306607378553,0.00047867660582985876,60 +dtmc,dense-n0100-s01729,dense,100,1729,return/bounded/k-10,1.94530753669292e-05,1.090112370232944e-06,1.7903696885705163e-05,2.034165580562633e-05,1.8934771025730612e-05,1.9793434646966115e-05,124 +dtmc,dense-n0100-s01729,dense,100,1729,return/bounded/k-100,0.00012515751494028533,5.117721024317033e-06,0.00011951033229706809,0.000129342101312047,0.00012277079702121706,0.00012650242459847394,87 +dtmc,dense-n0100-s01729,dense,100,1729,return/mean-recurrence,0.0007173495649349998,2.085218362092849e-05,0.0006894806498812574,0.0007368828598802628,0.000702338357341989,0.0007206934178700146,55 +dtmc,dense-n0100-s01729,dense,100,1729,simulation/10000,0.009745648571489645,0.0005483616851196284,0.009414573254616698,0.011654640762052233,0.009501904198259581,0.010823666998476256,29 +dtmc,dense-n0100-s01729,dense,100,1729,simulation/100000,0.0856261850642604,0.001003405418487091,0.08448921010312915,0.08620671533450756,0.08442485424893675,0.08624712500022724,10 +dtmc,dense-n0100-s01729,dense,100,1729,stationary,0.0007245183998020366,4.072270601203571e-05,0.0006414476197928057,0.0007449178651263032,0.0006778966932830846,0.0007342291670890214,55 +dtmc,dense-n0100-s01729,dense,100,1729,structure/classes-cold,0.00015364104185483935,8.315914369161473e-06,0.00014353869649948715,0.0001605757629887176,0.00014977307056185285,0.00015582369205031473,84 +dtmc,dense-n0100-s01729,dense,100,1729,structure/classes-lifecycle,0.001194233333323306,9.006666756855943e-05,0.0011223537455077501,0.0013052012615362937,0.0011480146336310564,0.00124492359997627,67 +dtmc,dense-n0100-s01729,dense,100,1729,structure/classes-warm/access,9.017052887038372e-09,4.791232680628975e-10,8.560910594776852e-09,1.12238524170801e-08,8.867728954235991e-09,9.159783124792842e-09,307 +dtmc,dense-n0100-s01729,dense,100,1729,structure/classes-warm/consumed,5.116206562291495e-07,1.084290267624469e-08,4.999801989768591e-07,5.214875146779432e-07,5.076972608697624e-07,5.141682824069614e-07,225 +dtmc,dense-n0100-s01729,dense,100,1729,structure/irreducible-cold,0.00013808358093055653,5.1983147155105965e-06,0.0001333869239930928,0.00014602999585479535,0.0001358607719752895,0.00014016951471978033,82 +dtmc,dense-n0100-s01729,dense,100,1729,structure/irreducible-warm,1.2108929550959044e-08,9.64560782089029e-10,1.1633333996938078e-08,1.5048966842678136e-08,1.1975896981772104e-08,1.226762945772611e-08,302 +dtmc,dense-n0100-s01729,dense,100,1729,visits/bounded-expectation/k-10,2.6303514131916926e-05,3.5223077417416978e-06,2.3196693222823975e-05,3.014698581845643e-05,2.5391613006829296e-05,2.7502049139822164e-05,120 +dtmc,dense-n0100-s01729,dense,100,1729,visits/bounded-expectation/k-100,0.00015995242990486856,5.563424478861553e-06,0.00015447808677450785,0.00016652272659650242,0.0001579240732618408,0.00016207842903289324,81 +dtmc,dense-n0100-s02718,dense,100,2718,construction/public-consumed,0.0006761649451681017,7.606376682658977e-05,0.0006001011783415119,0.0007519591359525594,0.0006372297714863505,0.0006979026657063514,77 +dtmc,dense-n0100-s02718,dense,100,2718,evolution/k-10,1.2905717979638893e-05,8.929693419009528e-07,1.2043573931318669e-05,1.3850875260074102e-05,1.247818428065544e-05,1.3189882524620113e-05,157 +dtmc,dense-n0100-s02718,dense,100,2718,evolution/k-100,0.00011588636041491924,5.2450557026220885e-06,0.00011108576505006674,0.00012182691865932844,0.00011402796491510295,0.00011694729689043016,113 +dtmc,dense-n0100-s02718,dense,100,2718,evolution/one-step,1.987052491332178e-06,9.623295428134234e-08,1.902504822971679e-06,2.1173386404934895e-06,1.951720925788824e-06,2.0035714497884774e-06,197 +dtmc,dense-n0100-s02718,dense,100,2718,finite-time/n-step/k-10,1.1955573946969317e-05,9.910229617537595e-08,1.1882664519362152e-05,1.246428707548018e-05,1.191185079702804e-05,1.2038343122337806e-05,133 +dtmc,dense-n0100-s02718,dense,100,2718,finite-time/n-step/k-100,9.735188763847368e-05,1.0974622260914474e-07,9.727118123901944e-05,9.763525187710062e-05,9.732558810202984e-05,9.741316575350033e-05,91 +dtmc,dense-n0100-s02718,dense,100,2718,finite-time/observation/k-10,1.5065206294209112e-05,3.5583371497868236e-07,1.475448253716094e-05,1.5762403329404965e-05,1.485787784834732e-05,1.5202000213321298e-05,131 +dtmc,dense-n0100-s02718,dense,100,2718,finite-time/observation/k-100,9.980054771100792e-05,8.647916591586079e-08,9.974165660847719e-05,9.99075717809011e-05,9.977418164264648e-05,9.984486831327605e-05,91 +dtmc,dense-n0100-s02718,dense,100,2718,finite-time/step,1.4191447209135654e-06,4.83827576622757e-07,1.0147858928475116e-06,2.1239333918081328e-06,1.2617647008378075e-06,1.7126608609550631e-06,186 +dtmc,dense-n0100-s02718,dense,100,2718,hitting-probability/cold-all-states,0.0005885092648487462,4.5301803018656973e-05,0.0005316855369305255,0.0006240419517360771,0.0005546055333979893,0.0006022660280195103,55 +dtmc,dense-n0100-s02718,dense,100,2718,hitting-probability/warm-lookup,3.107629323741263e-08,4.0124617692291275e-09,2.7619868110301927e-08,4.2060865301835256e-08,2.9684318154043442e-08,3.346256734416261e-08,281 +dtmc,dense-n0100-s02718,dense,100,2718,hitting-time/cold-all-states,0.0006066932147440604,3.398387921919638e-05,0.0005727174121354685,0.0006385069375602669,0.0005894581981313725,0.000623425539197342,56 +dtmc,dense-n0100-s02718,dense,100,2718,hitting-time/warm-lookup,2.5999902019081372e-08,8.185024711860724e-10,2.529479419297214e-08,2.966290899465681e-08,2.5707097842271832e-08,2.6492031735147935e-08,286 +dtmc,dense-n0100-s02718,dense,100,2718,hitting/bounded/at-most/k-10,1.5508360704894536e-05,7.549327629824975e-08,1.5456037458433357e-05,1.5836538972012476e-05,1.5486970161353902e-05,1.5544100498364065e-05,128 +dtmc,dense-n0100-s02718,dense,100,2718,hitting/bounded/at-most/k-100,0.00010492110940057441,4.361334496176425e-07,0.00010460344394067017,0.0001071616828944143,0.00010471386776771397,0.00010534711112327664,90 +dtmc,dense-n0100-s02718,dense,100,2718,hitting/bounded/exact/k-10,1.54429624133088e-05,3.7198715599737377e-08,1.541227362450269e-05,1.5542457663096763e-05,1.543000598186217e-05,1.545414688939417e-05,129 +dtmc,dense-n0100-s02718,dense,100,2718,hitting/bounded/exact/k-100,0.00010422605696353843,1.0390517370761047e-07,0.00010413179008953195,0.00010436112245343301,0.00010417780721463373,0.00010426866046668209,90 +dtmc,dense-n0100-s02718,dense,100,2718,hitting/bounded/greater-than/k-10,1.5636325746428784e-05,1.6351297850535983e-07,1.5512484926914206e-05,1.6727387960508816e-05,1.5558854797911577e-05,1.584030671360043e-05,128 +dtmc,dense-n0100-s02718,dense,100,2718,hitting/bounded/greater-than/k-100,0.00010461726989665954,2.848948342502831e-07,0.00010439204674972704,0.00010534333192715449,0.00010447332485007779,0.00010474651130510771,90 +dtmc,dense-n0100-s02718,dense,100,2718,power/10,0.00027374538844243223,2.6831141778287137e-05,0.0002464187167735644,0.0002929846175949886,0.0002711164268889818,0.00027978491310457924,98 +dtmc,dense-n0100-s02718,dense,100,2718,power/100,0.0002861105769205516,1.0563343452164333e-05,0.0002758006213148442,0.0002990422125522868,0.00028320089300645383,0.0002890109047127355,95 +dtmc,dense-n0100-s02718,dense,100,2718,power/2,0.00016314480966511403,9.53247957518561e-06,0.0001536253057014564,0.00017265241100593087,0.0001584399653104495,0.00016587499956823075,107 +dtmc,dense-n0100-s02718,dense,100,2718,race/forward-committor,0.00044329266159957837,2.4542549515978765e-05,0.0004211130619691887,0.0004902701380780464,0.0004266212728742341,0.0004691926242230693,58 +dtmc,dense-n0100-s02718,dense,100,2718,return/bounded/k-10,1.2721991798508656e-05,3.928231594320009e-07,1.2381702500626371e-05,1.3479125118465163e-05,1.2583330519393914e-05,1.2958502338733524e-05,133 +dtmc,dense-n0100-s02718,dense,100,2718,return/bounded/k-100,0.0001008645837525061,1.2688284793209426e-07,0.00010076193041944255,0.00010113789246979637,0.00010080163507303516,0.00010092736577226127,91 +dtmc,dense-n0100-s02718,dense,100,2718,return/mean-recurrence,0.0005763366620764525,8.590997754082856e-07,0.0005753265061912591,0.0005770214475313573,0.0005759238821851528,0.0005765351835859813,60 +dtmc,dense-n0100-s02718,dense,100,2718,simulation/10000,0.007144345751294167,9.589250489457253e-06,0.0071376554867543015,0.007155253696247888,0.007142765753087588,0.007149479787767633,35 +dtmc,dense-n0100-s02718,dense,100,2718,simulation/100000,0.06682331557385623,5.925942678004781e-05,0.06680324216595182,0.06690656755478509,0.06679908320365939,0.0669305601089339,11 +dtmc,dense-n0100-s02718,dense,100,2718,stationary,0.0007127915573969054,2.0365157446503262e-05,0.0006953257608512541,0.0007490488787880167,0.0007000569201313498,0.0007244345145798953,55 +dtmc,dense-n0100-s02718,dense,100,2718,structure/classes-cold,0.0001756288424260582,3.7124692859356943e-06,0.00017314488297946067,0.00018092533030609887,0.000175034722714271,0.00017745843049072263,80 +dtmc,dense-n0100-s02718,dense,100,2718,structure/classes-lifecycle,0.0012633733616521708,3.613186394507792e-05,0.0012356426098719838,0.0013082692738819225,0.0012488323720558467,0.001273666692073815,66 +dtmc,dense-n0100-s02718,dense,100,2718,structure/classes-warm/access,1.0989668678729523e-08,5.85263664104698e-10,1.053343881199335e-08,1.4036963482526007e-08,1.0875600760393986e-08,1.1170708117733675e-08,304 +dtmc,dense-n0100-s02718,dense,100,2718,structure/classes-warm/consumed,5.970957580836e-07,6.501950631860365e-09,5.91550005096163e-07,6.11867684832649e-07,5.951867975433753e-07,5.981338921618836e-07,223 +dtmc,dense-n0100-s02718,dense,100,2718,structure/irreducible-cold,0.00015619134429897916,6.586979812135514e-06,0.0001462301485541199,0.00016148222099824733,0.0001519392408287108,0.00015928082617735356,82 +dtmc,dense-n0100-s02718,dense,100,2718,structure/irreducible-warm,1.1961078440710047e-08,8.215397766231269e-10,1.1337281433562621e-08,1.4247592970781751e-08,1.180550028314842e-08,1.2107392464108246e-08,302 +dtmc,dense-n0100-s02718,dense,100,2718,visits/bounded-expectation/k-10,1.5319503290811554e-05,2.0014187550962623e-07,1.515627656389322e-05,1.5819871159560602e-05,1.524741564613594e-05,1.5433058709006856e-05,129 +dtmc,dense-n0100-s02718,dense,100,2718,visits/bounded-expectation/k-100,0.00012455389805836602,9.114190626342898e-08,0.00012447674555605498,0.00012468489714422137,0.00012452285351155433,0.00012458332492499037,87 +dtmc,dense-n0100-s31415,dense,100,31415,construction/public-consumed,0.0005854999999598399,3.399544192447248e-07,0.0005847878787652448,0.0005857099886270589,0.0005851600455405952,0.0005856011933040563,81 +dtmc,dense-n0100-s31415,dense,100,31415,evolution/k-10,1.0121193573667661e-05,1.3160666112126384e-08,1.0111640284308863e-05,1.0150377784157172e-05,1.0119134772871793e-05,1.0123610910085705e-05,164 +dtmc,dense-n0100-s31415,dense,100,31415,evolution/k-100,9.507686214833342e-05,6.181812586388761e-08,9.502392123909056e-05,9.514105001142151e-05,9.506243628345304e-05,9.50870253060962e-05,118 +dtmc,dense-n0100-s31415,dense,100,31415,evolution/one-step,1.610449409847229e-06,8.949540231927954e-09,1.602040004489552e-06,1.6305835035993428e-06,1.6048230255794623e-06,1.6132626690624777e-06,202 +dtmc,dense-n0100-s31415,dense,100,31415,finite-time/n-step/k-10,1.2150983335838343e-05,2.30727510781782e-07,1.1961956288513274e-05,1.365671596431639e-05,1.2033255374692857e-05,1.2316300284708425e-05,135 +dtmc,dense-n0100-s31415,dense,100,31415,finite-time/n-step/k-100,9.72689361219894e-05,7.742542832616593e-08,9.720292311006535e-05,9.735653159997955e-05,9.723208536992648e-05,9.729379677952713e-05,92 +dtmc,dense-n0100-s31415,dense,100,31415,finite-time/observation/k-10,1.4502740923550848e-05,3.4841418414786285e-08,1.447270871402317e-05,1.4540290002585619e-05,1.4490271620090725e-05,1.4513204524094803e-05,131 +dtmc,dense-n0100-s31415,dense,100,31415,finite-time/observation/k-100,9.993904310830345e-05,7.34524151706586e-08,9.987192188737824e-05,0.00010002728711638358,9.989585087168961e-05,9.996767306690846e-05,91 +dtmc,dense-n0100-s31415,dense,100,31415,finite-time/step,8.865564816094578e-07,2.949313884407022e-08,8.669885014219639e-07,9.674692002048055e-07,8.789893159899338e-07,8.977247196486585e-07,185 +dtmc,dense-n0100-s31415,dense,100,31415,hitting-probability/cold-all-states,0.00044739385754967643,5.521413018073494e-07,0.00044691522423583534,0.0004480147436292084,0.0004471842314713918,0.0004478193669153067,61 +dtmc,dense-n0100-s31415,dense,100,31415,hitting-probability/warm-lookup,2.4108660008492367e-08,4.960734168879065e-10,2.36225623732516e-08,2.7487223032154355e-08,2.3999195820510312e-08,2.439625713042341e-08,288 +dtmc,dense-n0100-s31415,dense,100,31415,hitting-time/cold-all-states,0.00043925879014606933,8.154598983908389e-07,0.0004389471349505974,0.0004420694992101441,0.0004390539986409501,0.0004397292317522582,61 +dtmc,dense-n0100-s31415,dense,100,31415,hitting-time/warm-lookup,2.437556465662021e-08,4.911448511631366e-10,2.3893078664692336e-08,2.8323932143877537e-08,2.398481630997382e-08,2.4521160200161568e-08,288 +dtmc,dense-n0100-s31415,dense,100,31415,hitting/bounded/at-most/k-10,1.5912766501735075e-05,2.1382310816142578e-07,1.5628700789979154e-05,1.6064902760822755e-05,1.5837791005124974e-05,1.5952513082423708e-05,129 +dtmc,dense-n0100-s31415,dense,100,31415,hitting/bounded/at-most/k-100,0.00010455856494690145,8.6012098279632e-08,0.00010449769064222662,0.00010469092381963974,0.00010453798736467179,0.00010459775259151268,90 +dtmc,dense-n0100-s31415,dense,100,31415,hitting/bounded/exact/k-10,1.5616543929685246e-05,1.4437840182084411e-07,1.549333905603155e-05,1.5959729559218685e-05,1.5532057766583475e-05,1.5724333934485912e-05,129 +dtmc,dense-n0100-s31415,dense,100,31415,hitting/bounded/exact/k-100,0.00010459594934624328,1.767579740876018e-07,0.00010441826139463551,0.0001047675290956692,0.00010452729366206196,0.00010464915566633836,90 +dtmc,dense-n0100-s31415,dense,100,31415,hitting/bounded/greater-than/k-10,1.5590274837239228e-05,4.902934618429173e-08,1.555247950735447e-05,1.5652904126216615e-05,1.5581252796437184e-05,1.5598028462072335e-05,129 +dtmc,dense-n0100-s31415,dense,100,31415,hitting/bounded/greater-than/k-100,0.00010439954204308913,1.4933991196537026e-07,0.00010427313664015303,0.00010460281621419524,0.00010434712892308742,0.00010446517621077194,88 +dtmc,dense-n0100-s31415,dense,100,31415,power/10,0.00016542287243708493,1.1347425044939442e-07,0.00016532598376402502,0.00016561558348063689,0.00016538220193820273,0.0001654625660790629,107 +dtmc,dense-n0100-s31415,dense,100,31415,power/100,0.00020670265452570378,2.715216951493856e-07,0.00020650269002464334,0.0002070636585191393,0.00020663365385889147,0.00020686949679405434,102 +dtmc,dense-n0100-s31415,dense,100,31415,power/2,0.0001330147060798481,7.140898969078095e-08,0.00013296938093121724,0.00013323627742932537,0.00013299878020796435,0.00013303761119863743,111 +dtmc,dense-n0100-s31415,dense,100,31415,race/forward-committor,0.00041536309993009325,6.677593639189527e-07,0.00041476025039805615,0.0004164037623729725,0.00041507182124240154,0.00041572735924612803,62 +dtmc,dense-n0100-s31415,dense,100,31415,return/bounded/k-10,1.2419195090924182e-05,8.626329156032104e-08,1.2351748065838621e-05,1.2666350702301567e-05,1.2372685799800677e-05,1.2478940903208392e-05,132 +dtmc,dense-n0100-s31415,dense,100,31415,return/bounded/k-100,0.0001012696368640966,4.698233946196428e-07,0.00010088209463970909,0.00010394682933641513,0.0001010298732370517,0.00010174059971177485,91 +dtmc,dense-n0100-s31415,dense,100,31415,return/mean-recurrence,0.0005771733152582065,1.277419965175098e-06,0.0005761008988801304,0.0005802180790340756,0.0005768281430888435,0.000577820023871027,59 +dtmc,dense-n0100-s31415,dense,100,31415,simulation/10000,0.007109385251169442,8.71924748935271e-06,0.0071022494897577775,0.007118389999439907,0.007104236864093268,0.0071158254767873415,35 +dtmc,dense-n0100-s31415,dense,100,31415,simulation/100000,0.06657210227356038,7.997047644246746e-05,0.06655984269794621,0.06703717162417888,0.0665596391724345,0.06742227049835492,11 +dtmc,dense-n0100-s31415,dense,100,31415,stationary,0.0005738854380069825,8.997001553807276e-07,0.0005730031660812743,0.000574793825398956,0.0005735144511062471,0.0005742409709566485,60 +dtmc,dense-n0100-s31415,dense,100,31415,structure/classes-cold,0.00013032892606201042,2.901540331852942e-07,0.00013002727812110807,0.00013060339657511066,0.00013017776326441596,0.00013047470877709019,86 +dtmc,dense-n0100-s31415,dense,100,31415,structure/classes-lifecycle,0.0009043454842454098,5.708551831957998e-06,0.000895065204669311,0.0009082246533970908,0.0009004600214937437,0.0009067377552330274,72 +dtmc,dense-n0100-s31415,dense,100,31415,structure/classes-warm/access,8.597972870665833e-09,9.979470157047681e-11,8.516946660895785e-09,1.0658065245176354e-08,8.542141105137622e-09,8.711021528985522e-09,309 +dtmc,dense-n0100-s31415,dense,100,31415,structure/classes-warm/consumed,4.880195635131484e-07,1.0556556275034467e-09,4.873200787461536e-07,4.952688048541204e-07,4.876202599373764e-07,4.88668572332683e-07,226 +dtmc,dense-n0100-s31415,dense,100,31415,structure/irreducible-cold,0.00012200522542116232,3.9140673212801594e-07,0.00012154059739924415,0.000122365182263214,0.00012185459583750034,0.00012222927519663548,87 +dtmc,dense-n0100-s31415,dense,100,31415,structure/irreducible-warm,9.60013650249695e-09,9.549182196525984e-11,9.51816118940585e-09,1.198708273874002e-08,9.56134764190517e-09,9.663048570792477e-09,307 +dtmc,dense-n0100-s31415,dense,100,31415,visits/bounded-expectation/k-10,1.5183192503826908e-05,3.417354483255227e-08,1.5153469472934082e-05,1.5228635149671592e-05,1.5170265963104835e-05,1.5190280097083008e-05,130 +dtmc,dense-n0100-s31415,dense,100,31415,visits/bounded-expectation/k-100,0.00012453234381973744,9.326922978893548e-08,0.0001244232432546441,0.00012460591183369554,0.00012448066554497926,0.00012456608434922433,87 +dtmc,dense-n0250-s01729,dense,250,1729,construction/public-consumed,0.005166743429462831,3.9336837559218654e-05,0.005110735083968285,0.005183347964710864,0.005131860299962168,0.005176741372971654,40 +dtmc,dense-n0250-s01729,dense,250,1729,evolution/k-10,7.567548079980322e-05,5.451303615844718e-08,7.563564857060456e-05,7.577392408073239e-05,7.566255810391814e-05,7.568846701956066e-05,123 +dtmc,dense-n0250-s01729,dense,250,1729,evolution/k-100,0.0007483271500354425,4.208376464833114e-06,0.0007444059382927354,0.0007529154973985433,0.0007458038914017761,0.0007498104779923122,76 +dtmc,dense-n0250-s01729,dense,250,1729,evolution/one-step,9.04292195239871e-06,1.3868775845190552e-08,9.033390505989766e-06,9.082474623583964e-06,9.038137776746355e-06,9.055398758001893e-06,166 +dtmc,dense-n0250-s01729,dense,250,1729,hitting-probability/cold-all-states,0.003962633317710612,4.055345039960566e-05,0.00392206926560556,0.003990794034810581,0.003922638999453435,0.003984762826408057,26 +dtmc,dense-n0250-s01729,dense,250,1729,hitting-probability/warm-lookup,2.393886675906134e-08,3.185277503753417e-10,2.3680421301295293e-08,2.720835091809577e-08,2.3850173184908104e-08,2.4069446018165732e-08,288 +dtmc,dense-n0250-s01729,dense,250,1729,hitting-time/cold-all-states,0.003991236255630307,3.483019936538793e-05,0.003954649081837984,0.004020489448157605,0.003962179489077023,0.004010469044996647,26 +dtmc,dense-n0250-s01729,dense,250,1729,hitting-time/warm-lookup,2.4157630052275632e-08,2.80397684181338e-10,2.392291870930526e-08,2.7718697510663532e-08,2.4087133073176383e-08,2.4386169742936845e-08,287 +dtmc,dense-n0250-s01729,dense,250,1729,power/10,0.0011499993320155358,1.620611567068825e-05,0.0011264503499963515,0.0011643735659503211,0.0011414314516299275,0.0011555927318212028,68 +dtmc,dense-n0250-s01729,dense,250,1729,power/100,0.0016270457703456518,3.663050913208096e-05,0.001602412016750133,0.0016851070000224613,0.0016122474128410047,0.001648976037358807,60 +dtmc,dense-n0250-s01729,dense,250,1729,power/2,0.0008191947121449854,1.8725738931259044e-05,0.0007980739499129285,0.0008283031266883116,0.0008131041666072431,0.0008222449413369759,74 +dtmc,dense-n0250-s01729,dense,250,1729,race/forward-committor,0.0037489107230309552,1.2996568364628943e-05,0.003739438167940534,0.003771905223976845,0.0037421275595988846,0.0037649704239671477,26 +dtmc,dense-n0250-s01729,dense,250,1729,return/mean-recurrence,0.007442209500932115,4.758484679679266e-05,0.007406869909356742,0.0075261992194555205,0.007412325052065127,0.007515052000599098,24 +dtmc,dense-n0250-s01729,dense,250,1729,simulation/10000,0.010366932924572938,6.105577656410986e-05,0.010308916511955127,0.010444129860281138,0.010328948800937118,0.010385774576553515,30 +dtmc,dense-n0250-s01729,dense,250,1729,simulation/100000,0.07200837483105715,0.00022133359951632958,0.07163451807447027,0.07214327700276044,0.07151475381661757,0.07220833300380036,11 +dtmc,dense-n0250-s01729,dense,250,1729,stationary,0.007420599793311505,2.9738626694061302e-05,0.007387454859326681,0.007442783915939799,0.007389612631268392,0.007437024164876978,24 +dtmc,dense-n0250-s01729,dense,250,1729,structure/classes-cold,0.0008697081248101313,1.0190267078412211e-05,0.0008639604965471823,0.000887026891116734,0.0008673426127643324,0.0008795241048669835,47 +dtmc,dense-n0250-s01729,dense,250,1729,structure/classes-lifecycle,0.008315606445345717,6.457684018338662e-05,0.008253173799935861,0.008416503472189005,0.008266694329601402,0.008375282407440763,33 +dtmc,dense-n0250-s01729,dense,250,1729,structure/classes-warm/access,8.5969462014751e-09,9.116487818709198e-11,8.519838377318773e-09,1.0943040251731873e-08,8.568527144800379e-09,8.698981595464573e-09,309 +dtmc,dense-n0250-s01729,dense,250,1729,structure/classes-warm/consumed,1.2574898892636882e-06,3.940942273416885e-09,1.253960332618298e-06,1.2669143367445225e-06,1.2560949829106084e-06,1.2587762811515284e-06,207 +dtmc,dense-n0250-s01729,dense,250,1729,structure/irreducible-cold,0.0008654970345863452,1.0292680579818483e-05,0.0008568612290405298,0.000878397611996582,0.0008602394991612528,0.000870677630269998,47 +dtmc,dense-n0250-s01729,dense,250,1729,structure/irreducible-warm,1.0167261432139449e-08,5.47824776036737e-10,9.939192508532858e-09,1.295865676710268e-08,1.010842315592657e-08,1.0308504482481449e-08,306 +dtmc,dense-n0250-s02718,dense,250,2718,construction/public-consumed,0.005161092462638921,2.9284699184759216e-05,0.005097951769298212,0.00516922271595427,0.005131350467225468,0.005167935185319813,40 +dtmc,dense-n0250-s02718,dense,250,2718,evolution/k-10,7.582543962597527e-05,7.866036472959563e-08,7.576716500481409e-05,7.605820562815628e-05,7.579656061642808e-05,7.587204153875789e-05,122 +dtmc,dense-n0250-s02718,dense,250,2718,evolution/k-100,0.0007488969651234768,5.9014435486978755e-06,0.0007446795089535333,0.0007589152664737552,0.0007461138197082018,0.0007551041881015408,76 +dtmc,dense-n0250-s02718,dense,250,2718,evolution/one-step,9.093210154560758e-06,2.1137514608205256e-08,9.079386202566543e-06,9.1632308910653e-06,9.087794388917575e-06,9.100803168319767e-06,166 +dtmc,dense-n0250-s02718,dense,250,2718,hitting-probability/cold-all-states,0.0039286939541520755,1.6723575072580005e-05,0.003914583377991221,0.003945676766292131,0.003917908999772573,0.003944186898543353,26 +dtmc,dense-n0250-s02718,dense,250,2718,hitting-probability/warm-lookup,2.392305788838166e-08,3.1519645372935084e-10,2.3644449227433327e-08,2.7722734825311612e-08,2.3780487036317188e-08,2.4107901996808544e-08,287 +dtmc,dense-n0250-s02718,dense,250,2718,hitting-time/cold-all-states,0.004510213299254247,0.00025621880167069804,0.0043464838763254965,0.004973448797086761,0.0043975139160465915,0.004733942746353624,24 +dtmc,dense-n0250-s02718,dense,250,2718,hitting-time/warm-lookup,2.608010889767205e-08,2.165209131182825e-09,2.4592284296199425e-08,3.2577313315826205e-08,2.5698487538989057e-08,2.6856060402097183e-08,287 +dtmc,dense-n0250-s02718,dense,250,2718,power/10,0.0011478500878339029,2.056532744694711e-05,0.0011330549849662929,0.0011805777472141522,0.001142666977786466,0.0011522995737061972,68 +dtmc,dense-n0250-s02718,dense,250,2718,power/100,0.0016002097331996386,2.2714363068290343e-05,0.0015705278347013518,0.0016121123044285923,0.0015880967496611578,0.0016050416646370043,61 +dtmc,dense-n0250-s02718,dense,250,2718,power/2,0.0008244784453454853,2.6302695582086253e-05,0.0007999996476708193,0.0008667112600557914,0.0008176877762659723,0.0008348696809410653,74 +dtmc,dense-n0250-s02718,dense,250,2718,race/forward-committor,0.003734112886890309,1.5159974991080759e-05,0.0037192771454436684,0.0037523368214765055,0.0037217688330871937,0.0037430239982703434,26 +dtmc,dense-n0250-s02718,dense,250,2718,return/mean-recurrence,0.007429362818802474,2.5919767132209868e-05,0.007409491145586971,0.007479596207253457,0.00741037490661256,0.007476847332630617,24 +dtmc,dense-n0250-s02718,dense,250,2718,simulation/10000,0.010308803150837775,3.081604514523252e-05,0.010282167875272388,0.010347046419964086,0.010291475091732786,0.010334577601098686,30 +dtmc,dense-n0250-s02718,dense,250,2718,simulation/100000,0.07172527310871778,0.00027765336239503335,0.07151310746871098,0.07203691991162486,0.07149703427223192,0.07205248583341017,11 +dtmc,dense-n0250-s02718,dense,250,2718,stationary,0.007431297100111431,3.283809935185561e-05,0.007410400494931729,0.007495581819687056,0.00742027766633934,0.007479072738229933,24 +dtmc,dense-n0250-s02718,dense,250,2718,structure/classes-cold,0.0008695998675345133,7.852797678328696e-06,0.000863084174172558,0.0008783384825225236,0.0008661583601497114,0.0008741841666051187,47 +dtmc,dense-n0250-s02718,dense,250,2718,structure/classes-lifecycle,0.008268228027898457,3.2787189150678894e-05,0.008238220799830743,0.00830408325055032,0.008247776785927792,0.008284612666574065,33 +dtmc,dense-n0250-s02718,dense,250,2718,structure/classes-warm/access,8.599162070236384e-09,9.697320276854923e-11,8.51767945548912e-09,1.0918670176831355e-08,8.558956431103037e-09,8.650439074084043e-09,309 +dtmc,dense-n0250-s02718,dense,250,2718,structure/classes-warm/consumed,1.2537430369354846e-06,1.6582053110370924e-09,1.2527728493169034e-06,1.262531663756929e-06,1.2531216933908576e-06,1.2546728629505733e-06,207 +dtmc,dense-n0250-s02718,dense,250,2718,structure/irreducible-cold,0.0008546141471015289,9.975896814880345e-06,0.0008446382502866486,0.0008639326171340564,0.0008485754044072348,0.0008575634350089114,45 +dtmc,dense-n0250-s02718,dense,250,2718,structure/irreducible-warm,9.721123777576812e-09,2.0243318415011505e-10,9.548857004774909e-09,1.2068956581880152e-08,9.66118300864214e-09,9.769591162288951e-09,306 +dtmc,dense-n0250-s31415,dense,250,31415,construction/public-consumed,0.005180221916877296,4.242013852086106e-05,0.005123106062483902,0.005214992251873781,0.005163344959437381,0.005203042444436081,40 +dtmc,dense-n0250-s31415,dense,250,31415,evolution/k-10,7.569466403219849e-05,1.0813619398201545e-07,7.561999782623415e-05,7.58842909666357e-05,7.567271013217776e-05,7.573308426079997e-05,123 +dtmc,dense-n0250-s31415,dense,250,31415,evolution/k-100,0.0007421448082086932,7.211848375935498e-07,0.0007414737413356078,0.0007430453144464813,0.0007418748528938726,0.0007422570677030867,76 +dtmc,dense-n0250-s31415,dense,250,31415,evolution/one-step,9.07714447392133e-06,3.3442075445538295e-08,9.051537147092302e-06,9.173743513345376e-06,9.06558765952454e-06,9.102613555550298e-06,166 +dtmc,dense-n0250-s31415,dense,250,31415,hitting-probability/cold-all-states,0.003944018344554934,1.1809500153360346e-05,0.003934259908112128,0.003959292425286932,0.003937230996223026,0.0039549601359087925,26 +dtmc,dense-n0250-s31415,dense,250,31415,hitting-probability/warm-lookup,2.422914966277383e-08,5.627672575932062e-10,2.3729040794839386e-08,2.7049223004051002e-08,2.4005168811582533e-08,2.4349860567579624e-08,288 +dtmc,dense-n0250-s31415,dense,250,31415,hitting-time/cold-all-states,0.003947615954034105,1.8671293288906234e-05,0.003930668395824205,0.003966653545321606,0.003933708998374641,0.003955985451102606,26 +dtmc,dense-n0250-s31415,dense,250,31415,hitting-time/warm-lookup,2.412398308062373e-08,2.385796668008643e-10,2.390004066471859e-08,2.7385168903851915e-08,2.4017324560964444e-08,2.4235774132487156e-08,288 +dtmc,dense-n0250-s31415,dense,250,31415,power/10,0.0011463370575863867,1.7523957398257002e-05,0.0011249776125623612,0.001157427873834441,0.0011376231235813014,0.0011504830185408031,68 +dtmc,dense-n0250-s31415,dense,250,31415,power/100,0.0016044782046678433,1.886738358682083e-05,0.0015919785713776947,0.001625449079299523,0.0015980583993950859,0.0016139589420492775,61 +dtmc,dense-n0250-s31415,dense,250,31415,power/2,0.0008187689794679631,1.0596425694745924e-05,0.0008043137076518697,0.0008251859383803133,0.0008132314035551476,0.0008219498188202239,74 +dtmc,dense-n0250-s31415,dense,250,31415,race/forward-committor,0.0037571735678954468,2.4746944998494357e-05,0.0037358545217153327,0.003796436940623001,0.0037368826841967266,0.003782069333182234,26 +dtmc,dense-n0250-s31415,dense,250,31415,return/mean-recurrence,0.007414595354823498,1.3754542084390333e-05,0.007398135517692224,0.007425655878250836,0.0074044563301694805,0.007421280086841113,24 +dtmc,dense-n0250-s31415,dense,250,31415,simulation/10000,0.010333828306465877,4.2757820606661653e-05,0.010302523211614109,0.010383129459182953,0.01030420236261944,0.010373344448040195,30 +dtmc,dense-n0250-s31415,dense,250,31415,simulation/100000,0.07195788627458652,0.0001303492743942869,0.07179898366585905,0.07204071050146013,0.07177043033152586,0.07205702100327471,11 +dtmc,dense-n0250-s31415,dense,250,31415,stationary,0.007400626107928869,2.1567709418772972e-05,0.007384638447183534,0.007428060782071303,0.007386217998618332,0.007420040439481252,24 +dtmc,dense-n0250-s31415,dense,250,31415,structure/classes-cold,0.0008744585731100025,1.1021072298587745e-05,0.0008640352655264924,0.0008863341425680891,0.0008682893078205072,0.0008831089107843582,47 +dtmc,dense-n0250-s31415,dense,250,31415,structure/classes-lifecycle,0.00839829064359053,5.0686470783854916e-05,0.008349989586168617,0.008447207865517286,0.00835699999960424,0.008423679100815207,32 +dtmc,dense-n0250-s31415,dense,250,31415,structure/classes-warm/access,8.640900321092512e-09,1.2792082441067472e-10,8.517455834952764e-09,1.0816923653086027e-08,8.562063241366604e-09,8.69283213156354e-09,309 +dtmc,dense-n0250-s31415,dense,250,31415,structure/classes-warm/consumed,1.2555864160809196e-06,1.967189144000714e-09,1.2543205392398735e-06,1.2622082967821254e-06,1.2548696615973884e-06,1.257352942404538e-06,207 +dtmc,dense-n0250-s31415,dense,250,31415,structure/irreducible-cold,0.0008586530020693317,1.367351069347933e-05,0.0008486311091829596,0.0008733618072571069,0.000851996272103861,0.0008663787693049843,47 +dtmc,dense-n0250-s31415,dense,250,31415,structure/irreducible-warm,9.618811999437626e-09,1.0643108718974125e-10,9.518882146911703e-09,1.1912774826603955e-08,9.578006068629915e-09,9.681064603539335e-09,307 +dtmc,dense-n0500-s01729,dense,500,1729,construction/public-consumed,0.02890901876206834,0.0002241569246404524,0.028629432396545394,0.029053501181099114,0.02863698086429005,0.02905206713937029,18 +dtmc,dense-n0500-s01729,dense,500,1729,evolution/k-10,0.00029777892654912893,6.224804420771625e-07,0.0002971150693472298,0.0002983500787347181,0.0002975664125609448,0.0002979190795367461,94 +dtmc,dense-n0500-s01729,dense,500,1729,evolution/k-100,0.002951319124743653,1.997666509446919e-06,0.0029493173752569183,0.0029532931249767512,0.002950546353366173,0.0029526416561660787,50 +dtmc,dense-n0500-s01729,dense,500,1729,evolution/one-step,3.2685244262193605e-05,3.72153779069254e-08,3.265621240966098e-05,3.275126134923576e-05,3.267567096063394e-05,3.269416973052774e-05,140 +dtmc,dense-n0500-s01729,dense,500,1729,hitting-probability/cold-all-states,0.02867649077961687,0.0005590817745542154,0.02829756333890795,0.030124315790089895,0.028161845429817083,0.030264735833043233,11 +dtmc,dense-n0500-s01729,dense,500,1729,hitting-probability/warm-lookup,2.3811694597609005e-08,2.022821468393583e-10,2.3624134728356197e-08,2.735568836697149e-08,2.373124607998318e-08,2.3941746249708045e-08,288 +dtmc,dense-n0500-s01729,dense,500,1729,hitting-time/cold-all-states,0.030556276784669274,0.0011789294497118255,0.02961546643928159,0.03231113955043838,0.02951841700269142,0.032958624747698194,10 +dtmc,dense-n0500-s01729,dense,500,1729,hitting-time/warm-lookup,2.425723424595263e-08,3.735800935985459e-10,2.3915270500709438e-08,2.7804031816207435e-08,2.413663637379178e-08,2.4498412916726654e-08,287 +dtmc,dense-n0500-s01729,dense,500,1729,power/10,0.006665073853628512,7.814833662159832e-05,0.006578359358317112,0.006730321872693183,0.006619764453775826,0.006710703722395313,36 +dtmc,dense-n0500-s01729,dense,500,1729,power/100,0.011078597190568135,9.850508587832922e-05,0.010980092104689806,0.011170361001859419,0.011023703666675527,0.011159577357050563,29 +dtmc,dense-n0500-s01729,dense,500,1729,power/2,0.004147367706450279,5.4456729976020204e-05,0.0040974881823366074,0.004212096238188678,0.004117107333237955,0.004189301694168535,44 +dtmc,dense-n0500-s01729,dense,500,1729,race/forward-committor,0.02849857920082286,0.0009672461999192215,0.027864882687026693,0.03057238994006184,0.027838124751724536,0.030616689546150155,11 +dtmc,dense-n0500-s01729,dense,500,1729,return/mean-recurrence,0.06444686783409756,0.0041913574608164195,0.06100185317873183,0.07096777731827128,0.06089604795179184,0.07124735728887442,8 +dtmc,dense-n0500-s01729,dense,500,1729,simulation/10000,0.022166079101346742,0.00014191726812520095,0.022060651687752397,0.022312147875938625,0.02208735961822741,0.022307996369471943,20 +dtmc,dense-n0500-s01729,dense,500,1729,simulation/100000,0.08587400423069388,0.0022100830841130445,0.08517178097682764,0.09008056512266194,0.08500863085750357,0.09047282299798098,10 +dtmc,dense-n0500-s01729,dense,500,1729,stationary,0.05970950585781663,0.0002847928576917985,0.059341396008676384,0.05980016675130173,0.05916133366311745,0.05980371849727817,9 +dtmc,dense-n0500-s01729,dense,500,1729,structure/classes-cold,0.006792838750698138,4.878624410290921e-05,0.006662045165285235,0.0068204280899160285,0.006662045165285235,0.0068204280899160285,13 +dtmc,dense-n0500-s01729,dense,500,1729,structure/classes-lifecycle,0.04848662499915173,0.0004757917505974693,0.04808133749902481,0.04935654099972453,0.04808133749902481,0.04935654099972453,13 +dtmc,dense-n0500-s01729,dense,500,1729,structure/classes-warm/access,8.608441266142958e-09,1.0324905929413368e-10,8.516632624681177e-09,1.0775860489999084e-08,8.568479188486478e-09,8.7258199842677e-09,309 +dtmc,dense-n0500-s01729,dense,500,1729,structure/classes-warm/consumed,2.5350939146698458e-06,4.995676027443381e-09,2.5313900837382482e-06,2.555351233748136e-06,2.5334736913241154e-06,2.5376617207403626e-06,192 +dtmc,dense-n0500-s01729,dense,500,1729,structure/irreducible-cold,0.007112982144462876,0.00014410715084522963,0.006995583993557375,0.007401648001784149,0.006995583993557375,0.007401648001784149,13 +dtmc,dense-n0500-s01729,dense,500,1729,structure/irreducible-warm,9.625843845914714e-09,1.243976010992314e-10,9.517518044982675e-09,1.2261532466342984e-08,9.581735086171874e-09,9.729313103658719e-09,307 +dtmc,dense-n0500-s02718,dense,500,2718,construction/public-consumed,0.028445931270107395,0.00016814667008778657,0.028324065685200576,0.028757987826591287,0.028347182678631865,0.028731711875176792,18 +dtmc,dense-n0500-s02718,dense,500,2718,evolution/k-10,0.00029793977864756016,4.6734352619873286e-07,0.0002973211949343365,0.0002982039613989274,0.0002975967742117142,0.00029809057379366253,95 +dtmc,dense-n0500-s02718,dense,500,2718,evolution/k-100,0.0029485994624337763,1.2968818043593722e-06,0.002947437909558962,0.0029499798007633603,0.0029478416397205258,0.002949361446365993,50 +dtmc,dense-n0500-s02718,dense,500,2718,evolution/one-step,3.2708335287090476e-05,3.200564060426144e-08,3.268767244205135e-05,3.276720000051722e-05,3.2703805776108836e-05,3.2716662665561614e-05,140 +dtmc,dense-n0500-s02718,dense,500,2718,hitting-probability/cold-all-states,0.028385897999719925,0.00047355199898851605,0.02786782110448588,0.0286695740018331,0.02774660830036737,0.02885944999870844,11 +dtmc,dense-n0500-s02718,dense,500,2718,hitting-probability/warm-lookup,2.3808194683216394e-08,2.046835846010908e-10,2.3621796842704866e-08,2.728493138317011e-08,2.3734887961661986e-08,2.3929704683178713e-08,288 +dtmc,dense-n0500-s02718,dense,500,2718,hitting-time/cold-all-states,0.028254260500034434,0.0005673478979588246,0.02778895274459501,0.02860304253182322,0.027568837399303447,0.02882160839799326,11 +dtmc,dense-n0500-s02718,dense,500,2718,hitting-time/warm-lookup,2.4049227006057664e-08,1.8170049156653306e-10,2.388761705318576e-08,2.760258102281004e-08,2.39757541440346e-08,2.4208913129297327e-08,288 +dtmc,dense-n0500-s02718,dense,500,2718,power/10,0.006635978099984641,6.962078207339937e-05,0.006582747258793812,0.006710684557141837,0.006592183823265848,0.006677308688446076,36 +dtmc,dense-n0500-s02718,dense,500,2718,power/100,0.011032211407264523,9.366808732954278e-05,0.01093854331993498,0.011114375000313604,0.01098329861108343,0.011079196225769156,29 +dtmc,dense-n0500-s02718,dense,500,2718,power/2,0.004135369827049812,6.611073331013774e-05,0.004072346064882974,0.004208287507341937,0.004103558876464838,0.004165848777726448,44 +dtmc,dense-n0500-s02718,dense,500,2718,race/forward-committor,0.0270695050003269,0.000540921798165072,0.026706003738217986,0.027505713968518343,0.026528583202161827,0.027661191605147906,11 +dtmc,dense-n0500-s02718,dense,500,2718,return/mean-recurrence,0.059313464429578744,0.00015470075595658273,0.059243594001600286,0.05949221887567546,0.05915876367362216,0.060209074114229426,9 +dtmc,dense-n0500-s02718,dense,500,2718,simulation/10000,0.022192038449914738,0.00012511503520648906,0.022103433501115433,0.02235502012367111,0.022110550419536315,0.022323868077145925,20 +dtmc,dense-n0500-s02718,dense,500,2718,simulation/100000,0.08560002763260854,0.00020425187024860486,0.08529838906166073,0.08575521099983234,0.08504498386967803,0.0857767604993569,10 +dtmc,dense-n0500-s02718,dense,500,2718,stationary,0.05923498616660557,0.00020284249735091214,0.05906316699110903,0.05982707171434803,0.05903214366925466,0.060075499660645924,9 +dtmc,dense-n0500-s02718,dense,500,2718,structure/classes-cold,0.006673433200921864,5.534556806266553e-05,0.00664506827227094,0.0067908954952144995,0.00664506827227094,0.0067908954952144995,13 +dtmc,dense-n0500-s02718,dense,500,2718,structure/classes-lifecycle,0.047935375001543434,0.0002551039979152847,0.047717823768974856,0.04819047899945872,0.047717823768974856,0.04819047899945872,13 +dtmc,dense-n0500-s02718,dense,500,2718,structure/classes-warm/access,8.627938379217912e-09,1.2087930369364876e-10,8.516395391687482e-09,1.1135058627388943e-08,8.566479670871316e-09,8.727627107711534e-09,309 +dtmc,dense-n0500-s02718,dense,500,2718,structure/classes-warm/consumed,2.5315122610774507e-06,2.7627753190776958e-09,2.529916899814128e-06,2.5494463803220747e-06,2.5308032268001438e-06,2.5330624748773876e-06,192 +dtmc,dense-n0500-s02718,dense,500,2718,structure/irreducible-cold,0.006774337601382285,7.470059873802316e-05,0.006699637002644262,0.006840725193615072,0.006699637002644262,0.006840725193615072,13 +dtmc,dense-n0500-s02718,dense,500,2718,structure/irreducible-warm,9.609183007982416e-09,1.0723153735494532e-10,9.514571588750011e-09,1.1963849427337847e-08,9.57255570590561e-09,9.670762492222252e-09,307 +dtmc,dense-n0500-s31415,dense,500,31415,construction/public-consumed,0.028944651978539092,0.00018061452354029874,0.0288301922217923,0.02921550486849314,0.028833918737497008,0.029215422645608093,18 +dtmc,dense-n0500-s31415,dense,500,31415,evolution/k-10,0.00029864912268525936,9.758814325833988e-07,0.00029816466298088375,0.00029997407858918773,0.00029853790924376386,0.00029905509643046366,95 +dtmc,dense-n0500-s31415,dense,500,31415,evolution/k-100,0.002969595600572777,8.933899107325515e-06,0.0029605675528805576,0.0029780929506758535,0.0029666562513739336,0.002974621253434591,50 +dtmc,dense-n0500-s31415,dense,500,31415,evolution/one-step,3.285899919529374e-05,1.3174159794599854e-07,3.2742309888777724e-05,3.312032804183269e-05,3.281445711689564e-05,3.293736354032568e-05,139 +dtmc,dense-n0500-s31415,dense,500,31415,hitting-probability/cold-all-states,0.028968287001286324,0.0003359880026740335,0.028655740149836427,0.0293039473146564,0.02862938654884188,0.029304275003960358,11 +dtmc,dense-n0500-s31415,dense,500,31415,hitting-probability/warm-lookup,2.3930561634302082e-08,3.2689796443280113e-10,2.364391690524083e-08,2.7163307389220154e-08,2.3812565240870273e-08,2.4191791171936348e-08,288 +dtmc,dense-n0500-s31415,dense,500,31415,hitting-time/cold-all-states,0.029154882364144378,0.0004270506387745801,0.02852135519902471,0.029497331126913197,0.028247091399680357,0.029581933002918958,11 +dtmc,dense-n0500-s31415,dense,500,31415,hitting-time/warm-lookup,2.4148782836623068e-08,2.729404486229232e-10,2.3901090755351235e-08,2.742561448684077e-08,2.4065299181085923e-08,2.4336842237172995e-08,288 +dtmc,dense-n0500-s31415,dense,500,31415,power/10,0.006750396023047263,0.00010162170542488743,0.006667439833498585,0.0068773720161446434,0.006683814394019657,0.006827176658747098,36 +dtmc,dense-n0500-s31415,dense,500,31415,power/100,0.011074041666385407,7.873614266004636e-05,0.010992262768783033,0.01113681542795218,0.011005953722310046,0.01110630099881544,29 +dtmc,dense-n0500-s31415,dense,500,31415,power/2,0.004176487234738153,6.373929054317388e-05,0.004092299648985781,0.004230566464164959,0.00411822719026878,0.004193253466655733,44 +dtmc,dense-n0500-s31415,dense,500,31415,race/forward-committor,0.02767729166468295,0.000755358329236816,0.027388535420951404,0.028553442996538555,0.027166602094604805,0.028674235999157343,11 +dtmc,dense-n0500-s31415,dense,500,31415,return/mean-recurrence,0.0597293999948306,0.0002229204968898571,0.059551965498637095,0.06013950000245435,0.059506479497940745,0.06023836328573192,9 +dtmc,dense-n0500-s31415,dense,500,31415,simulation/10000,0.022561827176468797,0.00021228957106410318,0.022438033846852477,0.02291413668581299,0.02246174409060497,0.022901059041032568,20 +dtmc,dense-n0500-s31415,dense,500,31415,simulation/100000,0.08736026913512823,0.0006521796492355292,0.08668098906588663,0.08784946339801536,0.0865920501993969,0.08812849685105786,10 +dtmc,dense-n0500-s31415,dense,500,31415,stationary,0.059822991798864675,0.00034146413284664306,0.059566017859781696,0.06109697900683386,0.05948152766601803,0.06133237044398104,9 +dtmc,dense-n0500-s31415,dense,500,31415,structure/classes-cold,0.006961861346402051,0.0004637613978543827,0.006515791566926055,0.007544686890634528,0.0065077499311883,0.0076701843258475,12 +dtmc,dense-n0500-s31415,dense,500,31415,structure/classes-lifecycle,0.04860642700077733,0.0007239790841898283,0.0478824479165875,0.049152611165482085,0.0478824479165875,0.049152611165482085,13 +dtmc,dense-n0500-s31415,dense,500,31415,structure/classes-warm/access,8.62824733242062e-09,1.3798861118344779e-10,8.507865079624565e-09,1.091871400790132e-08,8.586022533154033e-09,8.720389242976976e-09,309 +dtmc,dense-n0500-s31415,dense,500,31415,structure/classes-warm/consumed,2.5343696282098513e-06,8.447189435660987e-09,2.5270500238459813e-06,2.5512164425407623e-06,2.531492465320663e-06,2.538245686427847e-06,192 +dtmc,dense-n0500-s31415,dense,500,31415,structure/irreducible-cold,0.00703155439987313,8.817039779387449e-05,0.006968312503886409,0.007146916997347337,0.006968312503886409,0.007146916997347337,13 +dtmc,dense-n0500-s31415,dense,500,31415,structure/irreducible-warm,9.680559072817951e-09,1.6414610996194632e-10,9.539188362615821e-09,1.2111394649238851e-08,9.62267213280489e-09,9.75279601765648e-09,306 +dtmc,dense-n1000-s01729,dense,1000,1729,construction/public-consumed,0.134079950034599,0.0016243484315054957,0.13191920852356512,0.13495715893986926,0.13066592366764476,0.13558566700521624,8 +dtmc,dense-n1000-s01729,dense,1000,1729,evolution/k-10,0.0019370911411384349,2.980147772364307e-06,0.0019351965809572041,0.0019539214050989058,0.0019362308353766421,0.001938036606368383,58 +dtmc,dense-n1000-s01729,dense,1000,1729,evolution/k-100,0.01934067776182062,4.291264957871632e-05,0.01930336743071166,0.01939517228575741,0.01931145409907913,0.01936644663033189,22 +dtmc,dense-n1000-s01729,dense,1000,1729,evolution/one-step,0.00020085018116768207,5.324782425954557e-07,0.00020047143971488256,0.00020143508318704842,0.0002007600346791596,0.00020102399555201243,103 +dtmc,dense-n1000-s01729,dense,1000,1729,simulation/10000,0.0734638056649904,0.0009686806636940021,0.07228885877864538,0.07388032600680494,0.07208259255599438,0.07405156800152989,11 +dtmc,dense-n1000-s01729,dense,1000,1729,simulation/100000,0.1484895901642934,0.0023178678263017782,0.1449715955453333,0.1487313748917326,0.143771468752675,0.14897066650155466,7 +dtmc,dense-n1000-s02718,dense,1000,2718,construction/public-consumed,0.13351636365696323,0.002045000854498838,0.1312238909684614,0.1352200251473429,0.13086261100155147,0.13543431933309572,8 +dtmc,dense-n1000-s02718,dense,1000,2718,evolution/k-10,0.001991209434077303,6.173720032535274e-06,0.0019865233095645507,0.0020069659795084664,0.001988997448910484,0.001995943750080187,57 +dtmc,dense-n1000-s02718,dense,1000,2718,evolution/k-100,0.01993507287625107,0.00014968587545029569,0.019785387000800774,0.020046750010806136,0.01978590829967288,0.020027424059020738,21 +dtmc,dense-n1000-s02718,dense,1000,2718,evolution/one-step,0.00020594023869351758,5.634856049766413e-07,0.000205514253807802,0.00020709619374726583,0.00020570948800350094,0.00020609854519451883,102 +dtmc,dense-n1000-s02718,dense,1000,2718,simulation/10000,0.07305091599118896,0.001026906769968472,0.07202949419257088,0.07509444474615685,0.07202400922122049,0.0762186060932105,11 +dtmc,dense-n1000-s02718,dense,1000,2718,simulation/100000,0.15004967699496774,0.0023652739885922924,0.14848600160233522,0.16064419449685374,0.14768440300637545,0.16926940999837825,7 +dtmc,dense-n1000-s31415,dense,1000,31415,construction/public-consumed,0.13370657999924634,0.0009912039365493064,0.13275208909435604,0.13430035641353502,0.132641949999379,0.13513036314231744,8 +dtmc,dense-n1000-s31415,dense,1000,31415,evolution/k-10,0.0020505884387269045,1.8346202933419015e-06,0.0020486652666780476,0.0020522234373856916,0.0020498066947362125,0.002051207833400916,57 +dtmc,dense-n1000-s31415,dense,1000,31415,evolution/k-100,0.020380288391136085,5.887673602347071e-05,0.0203538101722672,0.02441915412945101,0.02035861276295543,0.0242966065679866,20 +dtmc,dense-n1000-s31415,dense,1000,31415,evolution/one-step,0.00021392658712261075,3.355813407611094e-07,0.0002135710126124381,0.00021426009281884072,0.0002138773475839187,0.00021401390465780097,101 +dtmc,dense-n1000-s31415,dense,1000,31415,simulation/10000,0.0715032500011148,0.0016074831975856768,0.070359975923202,0.07310984881187324,0.06966982274752809,0.07311073319870047,11 +dtmc,dense-n1000-s31415,dense,1000,31415,simulation/100000,0.14324777099924782,0.0015591042489783435,0.14216366080290754,0.1455954375026825,0.14168866675026948,0.14692862500669435,7 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,construction/public-consumed,6.34864722532627e-06,1.0503156514957235e-08,6.343739009098678e-06,6.4046538542382995e-06,6.347196901811949e-06,6.352075386529854e-06,173 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,evolution/k-10,1.653880419255535e-06,1.1485676647194307e-08,1.6447014524956262e-06,1.686476198734627e-06,1.6495176008324309e-06,1.6663192689199657e-06,201 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,evolution/k-100,3.0678584679105012e-06,1.4707906100405729e-08,3.0578532540613252e-06,3.100533020713222e-06,3.06390751562385e-06,3.0757898154358068e-06,187 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,evolution/one-step,2.472149335446399e-07,1.1541983189681636e-08,2.353123890025306e-07,2.5360216943729614e-07,2.4549963748027914e-07,2.481270329798044e-07,240 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,finite-time/n-step/k-10,2.9093076884805436e-06,7.330286966020832e-09,2.903057348234646e-06,2.9215151056026423e-06,2.90825361476864e-06,2.9112662836855463e-06,164 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,finite-time/n-step/k-100,1.7492596821380505e-05,3.249217139358125e-08,1.746583603602003e-05,1.7546887579409432e-05,1.748347249411778e-05,1.7505246573790004e-05,140 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,finite-time/observation/k-10,3.3343071874225173e-06,8.733545393019947e-09,3.327822749549077e-06,3.347184357346233e-06,3.3320490533004053e-06,3.3380223654555874e-06,161 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,finite-time/observation/k-100,1.7931288163760206e-05,3.8397837956445055e-08,1.789868270593957e-05,1.805892041593475e-05,1.7911424788013038e-05,1.7948318034352232e-05,139 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,finite-time/step,7.52739125721364e-07,3.004366610950964e-09,7.50624072078957e-07,7.573229218777293e-07,7.521515804873966e-07,7.535076357736177e-07,191 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,hitting-probability/cold-all-states,1.6542969123375688e-05,7.406114369116706e-08,1.6489624232595225e-05,1.6680294300288362e-05,1.6519099548213787e-05,1.656632586524879e-05,137 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,hitting-probability/warm-lookup,2.5442081224856453e-08,1.6522310816901385e-09,2.412253354787837e-08,2.8321075840542286e-08,2.514687266478795e-08,2.5710316225149763e-08,287 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,hitting-time/cold-all-states,1.5046162627099658e-05,1.286783635536526e-07,1.4956249247317549e-05,1.519780942472741e-05,1.5008998021425588e-05,1.5106378622926923e-05,138 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,hitting-time/warm-lookup,2.4242504531277707e-08,3.564181549319669e-10,2.3903970002214452e-08,2.7267698577226516e-08,2.410668192016697e-08,2.4357090285942067e-08,288 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,hitting/bounded/at-most/k-10,3.27481101600518e-06,1.2026228815263188e-08,3.2661626698996224e-06,3.2930076100235585e-06,3.2721701030931946e-06,3.277768693502973e-06,162 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,hitting/bounded/at-most/k-100,1.8804331227803176e-05,1.6647086609763664e-08,1.8790552253255182e-05,1.8829927484013757e-05,1.8799633326337457e-05,1.8809739002332014e-05,139 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,hitting/bounded/exact/k-10,3.2403058787640606e-06,1.1363064776323551e-08,3.232706282720848e-06,3.2611615158580868e-06,3.238363684259176e-06,3.2436117766964022e-06,162 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,hitting/bounded/exact/k-100,1.8617029441064043e-05,2.1403078637984225e-08,1.860281125197526e-05,1.866083463022065e-05,1.8612813518201518e-05,1.8625044385376185e-05,139 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,hitting/bounded/greater-than/k-10,3.206193790556641e-06,1.1736640133972831e-08,3.1962424096215375e-06,3.2266903447150556e-06,3.2026918859032695e-06,3.2109790242210595e-06,162 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,hitting/bounded/greater-than/k-100,1.8921692959417628e-05,1.9493714928607564e-08,1.89078708485258e-05,1.9032919345076863e-05,1.8916681885206865e-05,1.8927635356497577e-05,139 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,power/10,4.3927405689222114e-06,2.0533001474062972e-08,4.375804736436734e-06,4.446263406670799e-06,4.382493255558236e-06,4.405924466836893e-06,181 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,power/100,5.693237237517314e-06,1.539642976749185e-08,5.681204362153515e-06,5.732312869300726e-06,5.688459652610593e-06,5.700406782639834e-06,176 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,power/2,3.3349306703628834e-06,1.917913474996051e-08,3.317341035215333e-06,3.3710232431824366e-06,3.3231881668343396e-06,3.3440126663905013e-06,187 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,race/forward-committor,1.5522094444387015e-05,8.003932780132463e-08,1.5470955035951377e-05,1.5663192062553025e-05,1.549994047011711e-05,1.5552565807746233e-05,138 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,return/bounded/k-10,2.9675144455145367e-06,9.219857838760595e-09,2.9613422336570372e-06,2.98773399699373e-06,2.966195619470625e-06,2.9697752324864267e-06,163 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,return/bounded/k-100,1.835807235008725e-05,2.0536616280473683e-08,1.834114536201187e-05,1.8385400417973743e-05,1.835325532070152e-05,1.8364097016898664e-05,139 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,return/mean-recurrence,7.14102962723975e-06,3.571881690623589e-08,7.114896989410162e-06,7.1996075408455255e-06,7.135021840892634e-06,7.147281877221125e-06,146 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,simulation/10000,0.006063072535350026,1.656970661227013e-05,0.006033786450456031,0.006076528025005246,0.006051632456629622,0.00607439343665611,38 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,simulation/100000,0.06117112136683621,0.00022094075150865325,0.061034736916796346,0.06293962177126862,0.06103153183333537,0.06320420155194975,12 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,stationary,6.619496917960806e-06,6.074184480770253e-08,6.564308463432761e-06,6.698046612048832e-06,6.610869947834081e-06,6.628174897547539e-06,147 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,structure/classes-cold,3.005190974565085e-06,1.2169667469889243e-08,2.9968250290857933e-06,3.021354100019631e-06,3.001131187942303e-06,3.0086797192511494e-06,163 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,structure/classes-lifecycle,8.52293927346918e-06,4.178856303393244e-08,8.486980587573578e-06,8.613393862352157e-06,8.498167235430488e-06,8.542432224603145e-06,167 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,structure/classes-warm/access,8.703478550644215e-09,1.8551181637034838e-10,8.528965663203622e-09,1.0792129877842513e-08,8.66767537482414e-09,8.781472808447944e-09,309 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,structure/classes-warm/consumed,4.126107831601065e-08,6.735566050072328e-10,4.064528150104762e-08,4.427231812899533e-08,4.1117340569806594e-08,4.146233836227548e-08,277 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,structure/irreducible-cold,1.9198258338320335e-06,4.837338231348905e-09,1.915121053848838e-06,1.9246004966261385e-06,1.918115991514084e-06,1.9210954930050637e-06,172 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,structure/irreducible-warm,9.605637308451376e-09,1.0452752757818495e-10,9.521205690539245e-09,1.2377577012604323e-08,9.56151341884436e-09,9.69911379217477e-09,307 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,visits/bounded-expectation/k-10,5.139723366776085e-06,1.2647504982114846e-08,5.128583170301477e-06,5.157755497147508e-06,5.137422544875918e-06,5.144521533169499e-06,152 +dtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,visits/bounded-expectation/k-100,3.688941801842776e-05,2.808950552585175e-08,3.6862898883565645e-05,3.6924095381133765e-05,3.6877722748413383e-05,3.689512253160877e-05,130 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,construction/public-consumed,6.364642452949681e-06,1.001515647817237e-08,6.359510647315109e-06,6.414101471602072e-06,6.362142435987783e-06,6.368706593733535e-06,173 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,evolution/k-10,1.6457489705814222e-06,3.001395323908885e-09,1.643632935494889e-06,1.67427968198774e-06,1.644655134297202e-06,1.6474784352657815e-06,201 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,evolution/k-100,3.056369594854976e-06,7.677504689039358e-09,3.0494782225931862e-06,3.065372796290549e-06,3.055444188823445e-06,3.057981668314336e-06,188 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,evolution/one-step,2.4560142021403765e-07,1.066079437281275e-08,2.3473395471343622e-07,2.541887367425381e-07,2.442188680707696e-07,2.4715298850374307e-07,241 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,finite-time/n-step/k-10,2.973666013276665e-06,2.2648242044277254e-08,2.949986542481525e-06,2.9915894517717807e-06,2.971553608646015e-06,2.9774979006542896e-06,164 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,finite-time/n-step/k-100,1.7524326782269766e-05,1.672210584854005e-08,1.7513405236424264e-05,1.755410196188997e-05,1.7519642123663872e-05,1.752968513046514e-05,140 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,finite-time/observation/k-10,3.377055386474031e-06,6.493846848633604e-09,3.3712044956466867e-06,3.384051473694592e-06,3.375047332163586e-06,3.380060000133447e-06,161 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,finite-time/observation/k-100,1.806756308908675e-05,4.973973437978168e-08,1.8037768022622913e-05,1.825650465572394e-05,1.8054740046363498e-05,1.8084574166735944e-05,139 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,finite-time/step,7.839989848434925e-07,4.8263044403771514e-09,7.784696221158346e-07,7.883590864877446e-07,7.830997879130909e-07,7.848353476680706e-07,191 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,hitting-probability/cold-all-states,1.6613913636317234e-05,8.710668867148208e-08,1.654834581872651e-05,1.6854083999836195e-05,1.659408763033461e-05,1.6658312663332113e-05,137 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,hitting-probability/warm-lookup,2.36652614773795e-08,1.1178749800521891e-10,2.3573468914939177e-08,2.6780954687228613e-08,2.3605138763621103e-08,2.379029144154e-08,288 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,hitting-time/cold-all-states,1.4987590811015166e-05,5.5875640819260756e-08,1.494732223705618e-05,1.5074039032022872e-05,1.4972411062207564e-05,1.5004218612922243e-05,138 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,hitting-time/warm-lookup,2.394893768500479e-08,1.2249479879626686e-10,2.3838493680755456e-08,2.7172939321255855e-08,2.3901751074271754e-08,2.4109833334825283e-08,288 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,hitting/bounded/at-most/k-10,3.312500969817241e-06,2.640796080373426e-08,3.28880947452493e-06,3.3464728633839613e-06,3.3016701913466623e-06,3.319989366556328e-06,161 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,hitting/bounded/at-most/k-100,1.8847795867379562e-05,2.928827549621965e-08,1.8826333969992285e-05,1.8894849362892403e-05,1.8840302804459793e-05,1.8856385518013086e-05,139 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,hitting/bounded/exact/k-10,3.2858601683670635e-06,1.379161188597988e-08,3.267870050811301e-06,3.295770596399651e-06,3.2814888298659615e-06,3.2874339051577384e-06,161 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,hitting/bounded/exact/k-100,1.8730957126008697e-05,3.7431974241810965e-08,1.8703339500135287e-05,1.8825145010244647e-05,1.8715489583579863e-05,1.875786215093268e-05,139 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,hitting/bounded/greater-than/k-10,3.272870383797789e-06,1.5132998406407387e-08,3.2612954901446452e-06,3.307634380269939e-06,3.2686554190331185e-06,3.2783557669193087e-06,161 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,hitting/bounded/greater-than/k-100,1.898963396861718e-05,1.9870706516240163e-08,1.8978117632913888e-05,1.90222063356947e-05,1.8984435149238555e-05,1.899390281680241e-05,139 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,power/10,4.425016572131325e-06,6.725218293729082e-09,4.421192628473318e-06,4.445556596521165e-06,4.423499219431878e-06,4.42866492428406e-06,181 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,power/100,5.755768661445753e-06,2.667883400175397e-08,5.738216567996863e-06,5.807923049247629e-06,5.748262642422762e-06,5.7659674322983995e-06,174 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,power/2,3.360687621550251e-06,6.489766926321159e-09,3.355739392605215e-06,3.3718480495596526e-06,3.3594540223356784e-06,3.362768691681755e-06,186 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,race/forward-committor,1.565071198913995e-05,1.1273974040715047e-07,1.5569857871219415e-05,1.5841324830434936e-05,1.5627126361959e-05,1.5698715243684525e-05,138 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,return/bounded/k-10,3.0337594668787804e-06,8.637126047277574e-09,3.0267137372306584e-06,3.0453003299108036e-06,3.0321908377802042e-06,3.0365635341565524e-06,163 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,return/bounded/k-100,1.840126047379956e-05,1.6158159000545806e-08,1.83883174398128e-05,1.8428845167981133e-05,1.839745277940328e-05,1.8405774568025178e-05,139 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,return/mean-recurrence,7.14009351624659e-06,4.633135262752912e-08,7.091036618688833e-06,7.182428675508702e-06,7.129173900466412e-06,7.150227542721176e-06,146 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,simulation/10000,0.006009974929744298,2.978048226226623e-05,0.005962542697445661,0.006028850115762907,0.005991537965166941,0.006018677397930462,38 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,simulation/100000,0.06137770057369683,0.00011708607922486514,0.061311109483410425,0.06155855283630058,0.06130233884479302,0.06159813594659323,12 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,stationary,6.5458153788047115e-06,2.85448636691082e-08,6.528057710597298e-06,6.626128076936645e-06,6.539243530951718e-06,6.552734098975791e-06,147 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,structure/classes-cold,2.9781428058626375e-06,1.0971676900840864e-08,2.969681796533659e-06,2.9971567372471057e-06,2.9753022055765897e-06,2.983970379680987e-06,163 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,structure/classes-lifecycle,8.379762718560072e-06,4.023112040472449e-08,8.351515308633404e-06,8.483828089518858e-06,8.363739479553293e-06,8.426329269858035e-06,168 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,structure/classes-warm/access,8.663000334520272e-09,1.7524774060477868e-10,8.493649367583232e-09,1.0896582844206827e-08,8.556905719049048e-09,8.749818034256678e-09,309 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,structure/classes-warm/consumed,4.072914898459822e-08,3.325997194469105e-10,4.0432168228379314e-08,4.4976637990292265e-08,4.0548786207678985e-08,4.1317586846325165e-08,277 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,structure/irreducible-cold,1.944335705887951e-06,8.632822802188546e-09,1.9366668462480403e-06,1.9559661255693207e-06,1.9422708669351837e-06,1.9457057891266246e-06,172 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,structure/irreducible-warm,9.603893757363998e-09,1.272241426810509e-10,9.491790667744043e-09,1.1818501205490204e-08,9.551173684902898e-09,9.724566879747552e-09,307 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,visits/bounded-expectation/k-10,5.155240923456835e-06,1.4484679889409199e-08,5.146001429428229e-06,5.184687679844215e-06,5.153127385738247e-06,5.159695463172714e-06,152 +dtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,visits/bounded-expectation/k-100,3.684301458684931e-05,3.98846683939924e-08,3.680763149051104e-05,3.689762548753566e-05,3.683380401033916e-05,3.685619354546651e-05,130 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,construction/public-consumed,6.360938602040192e-06,2.2880982754422672e-08,6.340906688908484e-06,6.534721857557694e-06,6.3491263464232806e-06,6.388889030656881e-06,173 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,evolution/k-10,1.6680001393861828e-06,2.1814607476577467e-08,1.6467847772433943e-06,1.6915307920854602e-06,1.6635491752385414e-06,1.6752226287975836e-06,201 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,evolution/k-100,3.0811817626137338e-06,3.319876070480585e-08,3.04916613086598e-06,3.1250351406866055e-06,3.068571231969779e-06,3.0883346404427712e-06,188 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,evolution/one-step,2.43692979770335e-07,8.657784978887742e-09,2.3516201039037068e-07,2.540486497713977e-07,2.429432759674977e-07,2.445565829333301e-07,241 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,finite-time/n-step/k-10,2.906981491794576e-06,1.298628639440685e-08,2.8973371025593093e-06,2.9265528307102306e-06,2.9032735256743486e-06,2.911013597327776e-06,164 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,finite-time/n-step/k-100,1.7370594382062342e-05,2.1764155532035835e-08,1.735283286347961e-05,1.7403578859203378e-05,1.736356376498576e-05,1.7379226231990167e-05,140 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,finite-time/observation/k-10,3.3533726232552397e-06,5.447171653832455e-09,3.3482383947730774e-06,3.3611508340118833e-06,3.3521633667987772e-06,3.3554451087185794e-06,161 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,finite-time/observation/k-100,1.7885294668799773e-05,4.375226066686771e-08,1.7847674505470663e-05,1.7991276526236504e-05,1.7869567212636724e-05,1.7902741405201615e-05,139 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,finite-time/step,7.643579614504252e-07,6.77963217851897e-09,7.593179548362139e-07,7.80426355773716e-07,7.627641081347913e-07,7.660374439393098e-07,191 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,hitting-probability/cold-all-states,1.6523309042033935e-05,1.1215645306805218e-07,1.6454860031575963e-05,1.670541291012397e-05,1.650507011900431e-05,1.6561533837684767e-05,137 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,hitting-probability/warm-lookup,2.427506045190124e-08,6.125942850109628e-10,2.385816385517532e-08,2.6914027606780983e-08,2.4127532515940486e-08,2.452710900032787e-08,288 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,hitting-time/cold-all-states,1.49779768060833e-05,1.2726247103415867e-07,1.4891116247299605e-05,1.5511404143933483e-05,1.4955824361630357e-05,1.5025957761380082e-05,138 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,hitting-time/warm-lookup,2.4721454303649393e-08,6.525809755134204e-10,2.4161283791044587e-08,2.7040497016685787e-08,2.454713917388506e-08,2.514821436436163e-08,287 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,hitting/bounded/at-most/k-10,3.2628760547251317e-06,9.612219336074133e-09,3.256211561340829e-06,3.322103643968604e-06,3.260706419030833e-06,3.266190703005622e-06,161 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,hitting/bounded/at-most/k-100,1.8765228728139863e-05,2.2725799021284138e-08,1.8749552595490626e-05,1.8799757197306633e-05,1.8761408599940214e-05,1.876980324417017e-05,139 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,hitting/bounded/exact/k-10,3.1893449887223567e-06,2.3398782918391542e-08,3.171949498202048e-06,3.238388247458109e-06,3.184844061663183e-06,3.1933992292574233e-06,162 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,hitting/bounded/exact/k-100,1.8710764308114735e-05,5.435469816339483e-08,1.86578222801761e-05,1.8768935637453047e-05,1.870327171425081e-05,1.872202484721017e-05,139 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,hitting/bounded/greater-than/k-10,3.210045744416058e-06,1.7617614856644014e-08,3.194847173915986e-06,3.2353660619471467e-06,3.2062334842563196e-06,3.212525632403705e-06,162 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,hitting/bounded/greater-than/k-100,1.88629627310937e-05,2.8219818371489697e-08,1.8838607508122833e-05,1.889528193765464e-05,1.8857368942056047e-05,1.8872231789983893e-05,139 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,power/10,4.445292499582923e-06,3.6280247613613114e-08,4.411372221740978e-06,4.51105783107526e-06,4.430288334753221e-06,4.458385746739514e-06,180 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,power/100,5.886683645146089e-06,1.1865341249956331e-07,5.788204955749979e-06,6.0763503868310225e-06,5.833242139142025e-06,5.936024248032119e-06,175 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,power/2,3.4007291436266937e-06,2.8774490878377872e-08,3.3767259173126146e-06,3.438670813323471e-06,3.395975965044241e-06,3.408844805222345e-06,186 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,race/forward-committor,1.547784147417528e-05,8.776035779492127e-08,1.5416392701219283e-05,1.5772320021465986e-05,1.5455801805809e-05,1.5517406583009306e-05,138 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,return/bounded/k-10,2.972714291638531e-06,8.423615395277245e-09,2.9669949031410915e-06,2.9930941776848966e-06,2.970485049800893e-06,2.9766014362494014e-06,163 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,return/bounded/k-100,1.8363085525509502e-05,1.8818892673799526e-08,1.8349989110610243e-05,1.842181231232213e-05,1.835814913176549e-05,1.83715077680247e-05,139 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,return/mean-recurrence,7.033591078802311e-06,4.192821502448046e-08,7.002150731121685e-06,7.1066276925774934e-06,7.019081655657054e-06,7.050038477766274e-06,146 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,simulation/10000,0.006009126031214972,6.4307066053245765e-06,0.005999117253997508,0.0060146759546944204,0.006005940844867533,0.006012378522758478,38 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,simulation/100000,0.06127130844870408,7.748379551219056e-05,0.06120450313667816,0.0613838955533408,0.0612039276067405,0.06141004696879203,12 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,stationary,6.746967297965054e-06,2.171433869119314e-07,6.532289908666024e-06,6.995312094788726e-06,6.617760043788571e-06,6.824624506407417e-06,147 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,structure/classes-cold,3.0022259091792615e-06,2.9245946363272617e-08,2.9817382107328615e-06,3.061867983347374e-06,2.9967045981431926e-06,3.0104922174981865e-06,159 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,structure/classes-lifecycle,8.543749572709203e-06,8.810433604183719e-08,8.458090130355052e-06,8.638695108269515e-06,8.51535533959242e-06,8.555611668762952e-06,167 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,structure/classes-warm/access,8.689270115361207e-09,1.803893240939041e-10,8.559624977525385e-09,1.089654102835847e-08,8.636643978323364e-09,8.78669049441407e-09,309 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,structure/classes-warm/consumed,4.466293442450213e-08,3.5577499847731973e-09,4.1088229295308575e-08,4.783005559164626e-08,4.366437457605408e-08,4.573175131963105e-08,275 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,structure/irreducible-cold,1.922439875636575e-06,2.0855866741239566e-08,1.9035141645425843e-06,1.9486515946498463e-06,1.913949039612408e-06,1.9282838331330222e-06,172 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,structure/irreducible-warm,1.0007372955255795e-08,4.0787636604962797e-10,9.684553958486797e-09,1.2780188497773547e-08,9.89724300644785e-09,1.0178095326334912e-08,306 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,visits/bounded-expectation/k-10,5.113259438436466e-06,1.6984452373724846e-08,5.1020634609961995e-06,5.403825734075244e-06,5.109163277098867e-06,5.1187159785558086e-06,152 +dtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,visits/bounded-expectation/k-100,3.678425882760405e-05,3.985513547458136e-08,3.6755408418834075e-05,3.684210828726835e-05,3.677371503097575e-05,3.679558892438372e-05,130 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,construction/public-consumed,3.714534261227013e-05,7.658031837803864e-08,3.707468728944497e-05,3.7235397166598626e-05,3.713164137460049e-05,3.716829900547643e-05,137 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,evolution/k-10,2.3249225110477273e-06,4.7646364149239396e-09,2.3229022892773562e-06,2.3745077284797933e-06,2.324133502334997e-06,2.326607592536514e-06,194 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,evolution/k-100,8.7737222808452e-06,4.7072982093358676e-08,8.714881173517884e-06,8.813636775920742e-06,8.756704398828278e-06,8.786019362291178e-06,167 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,evolution/one-step,3.9449861159024134e-07,8.068408462836472e-09,3.864633924733575e-07,4.055001513969914e-07,3.8988351560467934e-07,3.9609241427789475e-07,231 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,finite-time/n-step/k-10,3.723337360552111e-06,2.305248587129001e-08,3.704969424478899e-06,3.767979806839551e-06,3.7147151561372114e-06,3.734062374860514e-06,159 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,finite-time/n-step/k-100,2.412242501851734e-05,2.5947460796134567e-08,2.41056970308316e-05,2.41592594465153e-05,2.4119692035998582e-05,2.4130841841708805e-05,122 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,finite-time/observation/k-10,4.54205820404661e-06,1.44114902242797e-08,4.5303362087938415e-06,4.562166850519134e-06,4.537200385578449e-06,4.545561355087534e-06,154 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,finite-time/observation/k-100,2.5017557465652166e-05,4.268558726845518e-08,2.4968797145895102e-05,2.5045908020756273e-05,2.4995023739479838e-05,2.502683905197719e-05,121 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,finite-time/step,8.296776055395987e-07,5.320268627921422e-09,8.216582596249946e-07,8.332578387873801e-07,8.28184327904078e-07,8.306198596768249e-07,190 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,hitting-probability/cold-all-states,3.969076699947028e-05,6.435562733825143e-08,3.9652102110860456e-05,3.982787298944439e-05,3.9676643079170994e-05,3.9748772740660406e-05,115 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,hitting-probability/warm-lookup,2.3697847683174846e-08,1.0540467565994073e-10,2.3615466160243886e-08,2.765053787887874e-08,2.3658111706955186e-08,2.4169555013991986e-08,288 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,hitting-time/cold-all-states,3.694132771526807e-05,6.226070747859574e-08,3.689104687099908e-05,3.7021324215144386e-05,3.6923150311664725e-05,3.696902838003423e-05,115 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,hitting-time/warm-lookup,2.413332803258052e-08,2.466803435940076e-10,2.389881190988125e-08,2.7331176157728965e-08,2.39945328950182e-08,2.434527715144782e-08,288 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,hitting/bounded/at-most/k-10,4.2512577831838275e-06,9.228288190108042e-09,4.243669372963328e-06,4.264158314550662e-06,4.248716914239949e-06,4.254948036855479e-06,156 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,hitting/bounded/at-most/k-100,2.508685358935186e-05,2.5648454714926325e-08,2.505820418608565e-05,2.5111035108893065e-05,2.5074347660478637e-05,2.5093999458476903e-05,121 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,hitting/bounded/exact/k-10,4.219809184176009e-06,2.1423080875571808e-08,4.200105560165472e-06,4.250556691803615e-06,4.212337301961633e-06,4.223292771613626e-06,156 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,hitting/bounded/exact/k-100,2.5129663240094887e-05,2.5782544350215963e-08,2.5110349372920136e-05,2.5161029756526756e-05,2.5124514683617562e-05,2.5138456273723294e-05,121 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,hitting/bounded/greater-than/k-10,4.157347462689099e-06,1.8136760094184375e-08,4.136105908625158e-06,4.16816453995665e-06,4.1529977655348676e-06,4.161085361493346e-06,155 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,hitting/bounded/greater-than/k-100,2.5452839339376918e-05,3.557388099587806e-08,2.541920279901013e-05,2.5505198937025853e-05,2.543539275603297e-05,2.5465262226434876e-05,121 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,power/10,1.6409646265990292e-05,2.0623091069295208e-08,1.639136146663605e-05,1.6435099149837162e-05,1.64046241692364e-05,1.6412031809089794e-05,154 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,power/100,2.017366111643361e-05,1.0765211403916551e-07,2.0047334036363992e-05,2.0272658698341214e-05,2.014208343243548e-05,2.0197584568625653e-05,150 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,power/2,1.3291894359411723e-05,1.5061453815534234e-08,1.3284480367751494e-05,1.3419586425553008e-05,1.3289430181205434e-05,1.330399189364469e-05,158 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,race/forward-committor,3.8461404896917796e-05,4.0142780001248794e-07,3.819595480712855e-05,4.010283792985048e-05,3.82938847011223e-05,3.900767248859139e-05,115 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,return/bounded/k-10,3.7922266974697374e-06,7.0393541566938174e-09,3.7873783299179584e-06,3.8041457363212385e-06,3.7911454973818994e-06,3.7936950748814732e-06,158 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,return/bounded/k-100,2.476752310106131e-05,2.18916615742645e-08,2.475100480533263e-05,2.4792076708896758e-05,2.4761226633008986e-05,2.4773665162766438e-05,122 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,return/mean-recurrence,1.861669417707828e-05,3.337412756729971e-08,1.859209994663439e-05,1.8661154012382955e-05,1.8609961392178396e-05,1.8630805090022504e-05,126 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,simulation/10000,0.006084334057151055,5.936478373769205e-06,0.00607768802783442,0.006089871813962115,0.006080094914687698,0.006086175952306574,38 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,simulation/100000,0.061246739111326554,6.442530775530031e-05,0.06120633846921919,0.06129101124381784,0.06118456243802939,0.061312161496475295,12 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,stationary,1.7576473675088433e-05,3.3797130686204224e-08,1.7550254540273868e-05,1.7630048817266844e-05,1.7568700422998516e-05,1.7587529680672654e-05,127 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,structure/classes-cold,5.95800773719484e-06,1.1359620190367335e-08,5.950057402740766e-06,5.974241811584807e-06,5.954914942978778e-06,5.961105421961426e-06,149 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,structure/classes-lifecycle,4.286356593789762e-05,2.3257145671817542e-08,4.2847443122676524e-05,4.291278392801442e-05,4.285670449627169e-05,4.2868643014521014e-05,134 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,structure/classes-warm/access,8.611488105253352e-09,9.933010125302554e-11,8.527336876922702e-09,1.0775860489999084e-08,8.566674860494658e-09,8.666275410748408e-09,309 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,structure/classes-warm/consumed,1.0616437483055358e-07,4.678748293546756e-10,1.0588308582960857e-07,1.1104904323084546e-07,1.0608107078115682e-07,1.0631896449368277e-07,257 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,structure/irreducible-cold,3.278596099338165e-06,5.851390913689652e-09,3.2727912184782326e-06,3.2850136146104583e-06,3.2767462742367845e-06,3.280164281513249e-06,161 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,structure/irreducible-warm,9.643425368718717e-09,1.2935384412392416e-10,9.522334697381958e-09,1.186756301892172e-08,9.586673493064533e-09,9.726920222047144e-09,307 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,visits/bounded-expectation/k-10,6.1319909435226005e-06,1.5556546474172464e-08,6.112315393861371e-06,6.1457503761630505e-06,6.128160166554153e-06,6.137976146158121e-06,149 +dtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,visits/bounded-expectation/k-100,4.342792440677084e-05,7.773209725509157e-08,4.335970152169466e-05,4.3584702264827983e-05,4.340508551323646e-05,4.347055489586255e-05,117 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,construction/public-consumed,3.710380119311194e-05,8.482981139487856e-08,3.703846148430155e-05,3.7214912274002766e-05,3.7086666665143436e-05,3.712679994154117e-05,137 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,evolution/k-10,2.3126380193042403e-06,2.487656344391617e-09,2.311243676618139e-06,2.32428358851439e-06,2.3123019748827617e-06,2.313545904408631e-06,194 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,evolution/k-100,8.757436815486795e-06,4.5974275889464246e-08,8.684249264695427e-06,8.79552504827821e-06,8.747407105854816e-06,8.768534133944055e-06,167 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,evolution/one-step,3.94289898476825e-07,8.47832833318089e-09,3.858083182095427e-07,4.023809142642646e-07,3.8754896694879994e-07,3.95168836829079e-07,231 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,finite-time/n-step/k-10,3.7842576012490287e-06,4.214646443155606e-08,3.7469884200251067e-06,3.853942233156673e-06,3.774081303272562e-06,3.793518337504071e-06,158 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,finite-time/n-step/k-100,2.4448713740311815e-05,2.9890916624461487e-07,2.4186044210096747e-05,2.543906654805581e-05,2.433848903183763e-05,2.4680329564337928e-05,118 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,finite-time/observation/k-10,5.342209628420924e-06,7.146506466869281e-07,4.588389270034023e-06,5.820447428389913e-06,4.63475276825835e-06,5.624020259022342e-06,154 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,finite-time/observation/k-100,2.5750000543299396e-05,5.911809140113566e-07,2.516994400163455e-05,2.6341094088111628e-05,2.539930920604439e-05,2.6155238921481733e-05,120 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,finite-time/step,8.061657945155231e-07,3.638035790969018e-09,8.033210647048483e-07,8.143620343980565e-07,8.050824924625692e-07,8.076422850346505e-07,190 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,hitting-probability/cold-all-states,3.998729103870343e-05,1.8054371169581222e-07,3.98521514991602e-05,4.056660611495955e-05,3.992952635366058e-05,4.008675277557794e-05,114 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,hitting-probability/warm-lookup,2.378814541228441e-08,1.8230978012156848e-10,2.3624498142626697e-08,2.7549020247387113e-08,2.3701566802431203e-08,2.3956519089193002e-08,288 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,hitting-time/cold-all-states,3.69821777847151e-05,5.371561892726276e-08,3.694280133313514e-05,3.70819464912459e-05,3.696828075721017e-05,3.7004285591787524e-05,115 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,hitting-time/warm-lookup,2.429910977846799e-08,4.2029066972001455e-10,2.388644119302844e-08,2.765057785666783e-08,2.3956141068424832e-08,2.4486494111664728e-08,288 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,hitting/bounded/at-most/k-10,4.236442798796998e-06,4.271168410004016e-08,4.201864319706054e-06,4.330579926433515e-06,4.227710131511166e-06,4.258211813990537e-06,156 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,hitting/bounded/at-most/k-100,2.507479530809118e-05,7.341576519232171e-08,2.5021718413870514e-05,2.5263461937883044e-05,2.5046878363355063e-05,2.5116383159443926e-05,120 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,hitting/bounded/exact/k-10,4.191134251202399e-06,3.646780691772112e-08,4.157300979941529e-06,4.228871976930312e-06,4.179352440081099e-06,4.199461467233678e-06,156 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,hitting/bounded/exact/k-100,2.5427355262030276e-05,4.074672377816153e-07,2.512201303016745e-05,2.604017026897054e-05,2.5331482939511232e-05,2.5703242775335006e-05,121 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,hitting/bounded/greater-than/k-10,4.181656601529772e-06,4.919435451416419e-08,4.1354647082936154e-06,4.235187029963341e-06,4.165531852360838e-06,4.2008561064736e-06,156 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,hitting/bounded/greater-than/k-100,2.5716119369537667e-05,2.865366362315221e-07,2.5453188636279464e-05,2.6373855819526527e-05,2.5606537677445924e-05,2.5865924186955514e-05,121 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,power/10,1.6436033721673704e-05,4.2943061189026704e-08,1.6404754454104653e-05,1.6493498464946897e-05,1.6425327430074556e-05,1.6442567898893556e-05,154 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,power/100,2.0286319386260608e-05,8.434605770966525e-08,2.021700732960716e-05,2.038687720353286e-05,2.02693526063485e-05,2.030757979383229e-05,150 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,power/2,1.3280668469525552e-05,2.4838467063807892e-08,1.3264271377811525e-05,1.3415163868138244e-05,1.327306475993198e-05,1.329101390379787e-05,158 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,race/forward-committor,3.781037633756108e-05,6.751599529548013e-08,3.7754349198355254e-05,3.790135337576252e-05,3.7783398875035344e-05,3.78456362077834e-05,115 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,return/bounded/k-10,3.804638974049077e-06,3.68527421184149e-08,3.770510013997934e-06,3.8478137401505255e-06,3.791295369708983e-06,3.8119941065407015e-06,158 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,return/bounded/k-100,2.5164520824762155e-05,3.8511522473590824e-07,2.47851307061932e-05,2.556938760724092e-05,2.4997720448550598e-05,2.5452987676293686e-05,121 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,return/mean-recurrence,1.8720472022929847e-05,1.7735746966582208e-07,1.8574316831640532e-05,1.9101400576658424e-05,1.8660718352683552e-05,1.8821243258644732e-05,126 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,simulation/10000,0.006160608302161563,5.050984843612844e-05,0.006120285552606219,0.006255113532422408,0.006131428277715006,0.006202382922660595,37 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,simulation/100000,0.06238355718778621,0.0001238584757735986,0.06228540682554416,0.06250726740382831,0.06226025106924579,0.0625074156635598,12 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,stationary,1.75036667232317e-05,2.9528647163797262e-08,1.74813677338269e-05,1.7588743033362396e-05,1.7493255759155987e-05,1.7513554719063262e-05,127 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,structure/classes-cold,5.888079492683486e-06,1.6156811224454923e-08,5.874882128342855e-06,5.908845485687569e-06,5.884240942966295e-06,5.89492570610513e-06,148 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,structure/classes-lifecycle,4.287812516849954e-05,3.9941989919441547e-08,4.2851780596623215e-05,4.298357375356029e-05,4.286741037855106e-05,4.289113749109674e-05,133 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,structure/classes-warm/access,8.650436359680904e-09,1.3393233556934834e-10,8.51993198248655e-09,1.0775860489999084e-08,8.580277871986308e-09,8.716568125235427e-09,309 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,structure/classes-warm/consumed,1.0643907527226204e-07,5.61630291142942e-10,1.0599789846245321e-07,1.1139582056785002e-07,1.0610261194276286e-07,1.0678429098992486e-07,257 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,structure/irreducible-cold,3.2592252571672455e-06,8.442188722328876e-09,3.252036765696028e-06,3.269338951136635e-06,3.2563641085740335e-06,3.261436969769732e-06,161 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,structure/irreducible-warm,9.629181411183592e-09,1.3128523309954741e-10,9.516668398920212e-09,1.1860270885450916e-08,9.54828621161002e-09,9.736800195351783e-09,307 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,visits/bounded-expectation/k-10,6.152313120397188e-06,5.6783757673518545e-08,6.106445589201066e-06,6.234678252560524e-06,6.132735794189533e-06,6.182537338015838e-06,147 +dtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,visits/bounded-expectation/k-100,4.414491825533491e-05,7.191047313494993e-07,4.3416426966099865e-05,4.4714156423269966e-05,4.370013879164808e-05,4.4519576256403305e-05,117 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,construction/public-consumed,3.784336734738923e-05,6.105028260367784e-07,3.739702110176678e-05,3.9081027757169475e-05,3.761862463686071e-05,3.83250718997614e-05,137 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,evolution/k-10,2.3932255479395195e-06,6.275399775193057e-08,2.356324783150099e-06,2.8316277565472125e-06,2.375440792417781e-06,2.4550771251177557e-06,192 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,evolution/k-100,9.151712014725893e-06,1.7357587259854318e-07,8.893587877220133e-06,9.277800885348862e-06,9.112488977235847e-06,9.191578806623763e-06,166 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,evolution/one-step,3.978667633965044e-07,9.825451595710482e-09,3.9145232161258675e-07,4.1818455168229515e-07,3.970173208848937e-07,4.013679174430747e-07,230 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,finite-time/n-step/k-10,3.751516135619773e-06,3.178589153778844e-08,3.7258166036296514e-06,3.8024316858928234e-06,3.7430541447570754e-06,3.7584705838475757e-06,159 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,finite-time/n-step/k-100,2.4593099832523568e-05,4.0520705785893676e-07,2.4227876565419137e-05,2.5439554721944863e-05,2.4385273340339686e-05,2.49968133074516e-05,121 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,finite-time/observation/k-10,4.534856998361647e-06,3.0607369326339897e-08,4.509469909162739e-06,4.583877738633417e-06,4.522437302512117e-06,4.540375604835363e-06,155 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,finite-time/observation/k-100,2.512163087195749e-05,1.564488045538489e-07,2.497924663569598e-05,2.5436258053438703e-05,2.5065980284410877e-05,2.5198986079847535e-05,120 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,finite-time/step,8.081038062457909e-07,8.960690789283469e-09,7.992800544897078e-07,8.171995884067332e-07,8.061401652459606e-07,8.097231319025255e-07,190 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,hitting-probability/cold-all-states,4.057325796360273e-05,7.938663595983235e-07,4.0048064556178505e-05,4.2000008348126855e-05,4.0287267046269425e-05,4.139473719585661e-05,115 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,hitting-probability/warm-lookup,2.4062174668983607e-08,4.334593162789778e-10,2.370960427779007e-08,2.6845515615188e-08,2.3982964989593852e-08,2.437777761960386e-08,288 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,hitting-time/cold-all-states,3.75181057040065e-05,4.771047446638048e-07,3.715788284188988e-05,3.815903215281059e-05,3.7367998932798706e-05,3.77502030460164e-05,115 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,hitting-time/warm-lookup,2.5066379148264464e-08,1.0361328696655444e-09,2.415006791799411e-08,2.7897570123914215e-08,2.472529987050963e-08,2.5168953539440096e-08,287 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,hitting/bounded/at-most/k-10,4.253884796659933e-06,4.614417530693268e-08,4.216740743806319e-06,4.38517332643792e-06,4.2386984313629465e-06,4.280345433398605e-06,156 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,hitting/bounded/at-most/k-100,2.5432862457819283e-05,3.8726804112749295e-07,2.507488666610284e-05,2.6010245180754155e-05,2.5283591144621408e-05,2.5700945215784523e-05,121 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,hitting/bounded/exact/k-10,4.233793895859587e-06,6.870552958265821e-08,4.167569947110082e-06,4.330345002745971e-06,4.21137870437279e-06,4.246116957397932e-06,156 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,hitting/bounded/exact/k-100,2.5256728598076637e-05,2.047723791088827e-07,2.509087470205605e-05,2.5655277307446385e-05,2.5152777703220232e-05,2.53447267988866e-05,121 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,hitting/bounded/greater-than/k-10,4.21677669330408e-06,7.844570125868263e-08,4.152956014788157e-06,4.328034510659894e-06,4.1991223321647185e-06,4.243307999243563e-06,156 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,hitting/bounded/greater-than/k-100,2.5739625925780274e-05,2.5354105067284044e-07,2.552854448367725e-05,2.616655469819458e-05,2.5639425864261864e-05,2.587667578105995e-05,121 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,power/10,1.699949949721382e-05,4.020933662758115e-07,1.660839916439727e-05,1.7454067554728913e-05,1.678650005487725e-05,1.7150596554898525e-05,153 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,power/100,2.1661740279337723e-05,9.241896480947526e-07,2.0894804932741073e-05,2.2722953181073537e-05,2.1343005312768016e-05,2.197536559326997e-05,148 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,power/2,1.3824785525198292e-05,4.949522643057128e-07,1.338785047758214e-05,1.496822221411599e-05,1.3670642753519738e-05,1.3998471634772027e-05,157 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,race/forward-committor,3.820820420514792e-05,3.065766188605019e-07,3.798503409147972e-05,3.8886809095372196e-05,3.812196222565102e-05,3.844486982312021e-05,115 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,return/bounded/k-10,3.853738488396589e-06,7.014149342523471e-08,3.7894806689634852e-06,3.9292133121546526e-06,3.8345202520043974e-06,3.8652501804531476e-06,158 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,return/bounded/k-100,2.5805392149116166e-05,4.566610321785769e-07,2.5202031090688916e-05,2.6112000341527164e-05,2.553641978496065e-05,2.5980828577100654e-05,121 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,return/mean-recurrence,1.8789228269769507e-05,4.3383760526517713e-07,1.8357618456231615e-05,1.9219995296485393e-05,1.865055178946684e-05,1.8916690827436034e-05,126 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,simulation/10000,0.0061852904539343645,4.1984154152238835e-05,0.0061457081634822925,0.0062763762286132466,0.006152521697399409,0.0062118462609803485,37 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,simulation/100000,0.06259007080225273,0.00011513255392653354,0.06252180037619029,0.0629113668939161,0.06251853825071724,0.06291758778717763,12 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,stationary,1.7724520452230156e-05,3.39445223602724e-07,1.748582654550369e-05,1.833984906520004e-05,1.757913707295077e-05,1.799932337924878e-05,127 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,structure/classes-cold,5.719044545130475e-06,2.984739544184859e-08,5.696119937749615e-06,5.767951106106651e-06,5.711445367153458e-06,5.73400085648665e-06,150 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,structure/classes-lifecycle,4.3085146199199446e-05,4.366273465018925e-07,4.2671854709499775e-05,4.3733624898722126e-05,4.291450416000733e-05,4.321323563892613e-05,134 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,structure/classes-warm/access,9.043587496518354e-09,5.039041071241012e-10,8.586238162313747e-09,1.2262659501048583e-08,8.970986194087384e-09,9.163795233462426e-09,309 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,structure/classes-warm/consumed,1.075172020074237e-07,1.1745922710868576e-09,1.0694842952380976e-07,1.1046713074105547e-07,1.0726809832363886e-07,1.0802649343570753e-07,257 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,structure/irreducible-cold,3.300631772084483e-06,2.8687798448435158e-08,3.27367456091726e-06,3.337662848126557e-06,3.293942427262664e-06,3.3114282857804072e-06,161 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,structure/irreducible-warm,9.799245403725019e-09,2.656558911243041e-10,9.590966428599795e-09,1.3037179589598853e-08,9.709601451153522e-09,9.960585018233311e-09,306 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,visits/bounded-expectation/k-10,6.198598909215135e-06,6.387731669793293e-08,6.138992694695253e-06,6.268862177818737e-06,6.180612320000752e-06,6.2245228204035854e-06,147 +dtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,visits/bounded-expectation/k-100,4.3705949354327724e-05,3.7886939712368517e-07,4.3369506683019507e-05,4.464829603699511e-05,4.350826010532718e-05,4.388471809378095e-05,117 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,construction/public-consumed,0.00014667800634832686,1.6882343592997226e-06,0.0001454128806389318,0.0001485116821791708,0.00014618866822342866,0.00014741388841302714,109 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,evolution/k-10,4.521023948403102e-06,1.281224418482087e-07,4.403522983167537e-06,4.849029051990288e-06,4.450109187792253e-06,4.618369038850359e-06,181 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,evolution/k-100,2.166757184881403e-05,7.975834599836365e-07,2.0871191360230214e-05,2.2485665263397653e-05,2.1596217024314028e-05,2.1806451484500882e-05,148 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,evolution/one-step,7.522486722902269e-07,1.530946270133545e-08,7.408952017714476e-07,7.71455833766581e-07,7.503516888206477e-07,7.553986699917537e-07,217 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,finite-time/n-step/k-10,5.8204588675293714e-06,5.550619524193745e-08,5.765273024074056e-06,5.875965062771309e-06,5.802960703686739e-06,5.8354164650767505e-06,149 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,finite-time/n-step/k-100,4.470673350436775e-05,6.949947482381273e-07,4.388016126599125e-05,4.5267456368263525e-05,4.4323401486514243e-05,4.4933245557821755e-05,108 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,finite-time/observation/k-10,7.3435598987810816e-06,8.117337349805202e-08,7.270442189167852e-06,7.460083102635932e-06,7.322177086132962e-06,7.3899216789607245e-06,145 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,finite-time/observation/k-100,4.5191601384431126e-05,4.314495582190031e-07,4.4816909443299856e-05,4.599543421860422e-05,4.510500012226035e-05,4.5377931408502424e-05,107 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,finite-time/step,8.359256888977265e-07,8.772974722448092e-09,8.281523005807421e-07,8.455878063494624e-07,8.342914315682314e-07,8.38039932071268e-07,189 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,hitting-probability/cold-all-states,0.000105063304477577,1.2379695713237018e-06,0.00010402246578974976,0.00010939205142774285,0.00010460208451749363,0.00010601453092707037,92 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,hitting-probability/warm-lookup,2.6864368214218182e-08,2.889393223332859e-09,2.411523857938322e-08,3.085075702808572e-08,2.567715328750618e-08,2.710188229706419e-08,288 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,hitting-time/cold-all-states,9.96663397770952e-05,6.497387245342755e-07,9.903666742670492e-05,0.00010053148231310321,9.932659376287148e-05,0.00010003005526313145,92 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,hitting-time/warm-lookup,2.522825365085397e-08,1.3040792844577462e-09,2.4011837670653557e-08,2.8988745695107464e-08,2.4844150707498962e-08,2.542022303476638e-08,287 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,hitting/bounded/at-most/k-10,6.7600536189474165e-06,2.4670609777111602e-08,6.7410206813191555e-06,6.813569019278326e-06,6.757148152888369e-06,6.767062421369536e-06,144 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,hitting/bounded/at-most/k-100,4.643027965283516e-05,6.532664321603259e-07,4.593718556613576e-05,4.78924812134479e-05,4.624798672866646e-05,4.6640861147156385e-05,107 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,hitting/bounded/exact/k-10,6.783125814286995e-06,7.483529489461124e-08,6.724165472631848e-06,6.900042521718394e-06,6.762448402200449e-06,6.801536653560353e-06,146 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,hitting/bounded/exact/k-100,4.607193073902075e-05,2.1241723405791537e-07,4.592917317507535e-05,4.6422403482215246e-05,4.601265722960513e-05,4.6149302389792136e-05,107 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,hitting/bounded/greater-than/k-10,6.817151398326342e-06,5.892858038410773e-08,6.765621861138505e-06,6.900840180549038e-06,6.799902960182986e-06,6.833244697190821e-06,147 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,hitting/bounded/greater-than/k-100,4.588827568187098e-05,7.074222196667865e-08,4.583294587384884e-05,4.6000455025884085e-05,4.586724902037531e-05,4.5900808929997894e-05,107 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,power/10,4.945052767248317e-05,1.4756358251178932e-06,4.7427566970966044e-05,5.063403923754842e-05,4.906692101934896e-05,4.9729251259122975e-05,132 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,power/100,5.9511948836686284e-05,1.8731765657773058e-06,5.716600949797138e-05,6.0868820130849965e-05,5.855629771107705e-05,5.990581408964977e-05,128 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,power/2,4.1624222325885464e-05,1.466746861077055e-06,4.017632018163289e-05,4.362726504399574e-05,4.1047894276504684e-05,4.23417968704598e-05,135 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,race/forward-committor,9.89031384000994e-05,5.098198891872004e-07,9.84655745607245e-05,0.00010043454030892463,9.866879265648775e-05,9.923999220165072e-05,92 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,return/bounded/k-10,5.86545912941994e-06,9.299887387193343e-09,5.85849726858829e-06,5.8777504818863235e-06,5.86419297824586e-06,5.867750183420463e-06,149 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,return/bounded/k-100,4.472543532500195e-05,5.113429584456281e-08,4.467517515130804e-05,4.477634818160474e-05,4.4704436147240974e-05,4.474012959968889e-05,108 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,return/mean-recurrence,7.021978313602723e-05,6.662256278516039e-08,7.015988191981497e-05,7.032991602385266e-05,7.019931635128517e-05,7.024422456644538e-05,99 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,simulation/10000,0.006075905096226591,1.9664916382882303e-05,0.006059500671123412,0.006096519627273224,0.006065223014603194,0.006083335497439088,38 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,simulation/100000,0.06114580662780633,7.132043720048387e-05,0.06109807000939327,0.06124004870889621,0.061089069215086056,0.06126638891691982,12 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,stationary,6.984485679865992e-05,9.774235098692106e-07,6.880590649573288e-05,7.067170362365629e-05,6.948759983060881e-05,7.014212344668577e-05,99 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,structure/classes-cold,1.1160406407871174e-05,9.294808900480336e-08,1.1070748480407916e-05,1.1276864926780501e-05,1.1133743941576944e-05,1.1185212864001191e-05,136 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,structure/classes-lifecycle,0.00015931622942750545,2.5266544516591076e-06,0.00015724572842579795,0.00016486460272232157,0.00015839453480221783,0.00016044531257648488,107 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,structure/classes-warm/access,8.682358899976093e-09,1.6325515861479224e-10,8.5373162882611e-09,1.103486435792899e-08,8.622026125808274e-09,8.782635621729829e-09,309 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,structure/classes-warm/consumed,2.3474551978454527e-07,2.422336565969093e-09,2.3280391089279762e-07,2.4443772638861876e-07,2.341723242122665e-07,2.3589594801777428e-07,241 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,structure/irreducible-cold,5.467094472787563e-06,5.579033784193164e-08,5.41429794800579e-06,5.522995835241627e-06,5.451932446627168e-06,5.484700222657484e-06,150 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,structure/irreducible-warm,9.860460708295854e-09,3.2239786273333357e-10,9.579089447126461e-09,1.1991141919589268e-08,9.757014794774514e-09,1.0011001262295152e-08,306 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,visits/bounded-expectation/k-10,8.371026782440364e-06,2.172774180681231e-08,8.351920856787499e-06,8.398995598811116e-06,8.363032094217398e-06,8.37701105384925e-06,142 +dtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,visits/bounded-expectation/k-100,6.421029635769163e-05,7.080040174353177e-08,6.415488052029082e-05,6.428753158213243e-05,6.420069140454523e-05,6.423970116884448e-05,100 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,construction/public-consumed,0.00014452811111954764,1.0292915917809874e-07,0.00014442515735195398,0.00014460597826721335,0.00014448437505052426,0.00014454301240999557,109 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,evolution/k-10,4.45445619919691e-06,6.061561093209494e-08,4.408613386360475e-06,4.62078654829915e-06,4.438953669240225e-06,4.474727161736651e-06,181 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,evolution/k-100,2.158387506835338e-05,2.620073463258438e-07,2.1242377987842765e-05,2.1750181615961345e-05,2.1534232527385324e-05,2.1619937498336033e-05,148 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,evolution/one-step,7.504275771403296e-07,1.60876900401236e-08,7.356429953274494e-07,7.721185108509911e-07,7.487284842681407e-07,7.53128718383859e-07,216 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,finite-time/n-step/k-10,5.713147725710912e-06,1.8760536988642168e-08,5.695440103457694e-06,5.739809137742909e-06,5.70595840592594e-06,5.7173969889986436e-06,150 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,finite-time/n-step/k-100,4.313678650864407e-05,4.6328680194720746e-08,4.3096411082883874e-05,4.318741420542614e-05,4.311373300914364e-05,4.315294713660629e-05,109 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,finite-time/observation/k-10,7.145202957935544e-06,1.6296567019162527e-08,7.134158412462174e-06,7.179943349575962e-06,7.141360587455513e-06,7.153739196447921e-06,145 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,finite-time/observation/k-100,4.478841941270031e-05,4.335001689559359e-08,4.4740821821713704e-05,4.4825073136524294e-05,4.4773958178006495e-05,4.480099919924719e-05,108 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,finite-time/step,8.175541661098178e-07,6.844031697923952e-09,8.118697250769872e-07,8.255138658587146e-07,8.156406037504778e-07,8.191185910031556e-07,190 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,hitting-probability/cold-all-states,0.0001040144703584074,1.384153752726004e-07,0.00010391764002013334,0.000104238411170497,0.00010395357029669257,0.00010408562591085107,92 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,hitting-probability/warm-lookup,2.3765192258676712e-08,1.3223197222803327e-10,2.364886143416979e-08,2.6632982177629227e-08,2.3703126230588584e-08,2.391547700923603e-08,288 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,hitting-time/cold-all-states,9.913881678861421e-05,1.025080866434098e-07,9.906819710104337e-05,9.92936410815067e-05,9.910981063633798e-05,9.919847590399967e-05,92 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,hitting-time/warm-lookup,2.4421258177320968e-08,5.189811715474008e-10,2.3915446942714883e-08,2.7877095373630342e-08,2.3986448592044446e-08,2.459490520710393e-08,288 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,hitting/bounded/at-most/k-10,6.735983772458423e-06,7.98128682756035e-09,6.731218908530646e-06,6.746211710909603e-06,6.734461605164557e-06,6.739061598918449e-06,147 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,hitting/bounded/at-most/k-100,4.569602252527543e-05,5.2863735138573115e-08,4.564405562004223e-05,4.5747056082226056e-05,4.567653826945409e-05,4.57121363003877e-05,107 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,hitting/bounded/exact/k-10,6.649383457053253e-06,1.4552037742597397e-08,6.636370560898417e-06,6.66515901684761e-06,6.6461003370115515e-06,6.6527255429801615e-06,145 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,hitting/bounded/exact/k-100,4.5720654877851873e-05,7.425824692526133e-08,4.567405281171902e-05,4.588966951030129e-05,4.570819089377122e-05,4.576583825822859e-05,107 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,hitting/bounded/greater-than/k-10,6.743903672492669e-06,1.3292220546982631e-08,6.7333434331960855e-06,6.764700132903686e-06,6.7403317307648455e-06,6.7475386510895745e-06,146 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,hitting/bounded/greater-than/k-100,4.579927366593796e-05,5.065544899790768e-08,4.574875322457047e-05,4.5849702678629205e-05,4.5778691518892605e-05,4.580973742947405e-05,107 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,power/10,4.9151384367986784e-05,1.4539856322990352e-06,4.768522569232613e-05,5.0537293668159974e-05,4.857746826228346e-05,4.945376713294536e-05,132 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,power/100,5.761500481681012e-05,8.822266464501998e-07,5.6914773161254086e-05,6.0658311347598176e-05,5.73167564594394e-05,5.823126787683482e-05,128 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,power/2,4.0352304895399254e-05,2.3586666310077535e-07,4.017569461976989e-05,4.1812216889039144e-05,4.026136362385428e-05,4.0716833527665e-05,135 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,race/forward-committor,9.880866296691258e-05,9.479187134262332e-08,9.872739926958425e-05,9.893524977713676e-05,9.878229483509073e-05,9.883175051365265e-05,92 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,return/bounded/k-10,5.8413817706906175e-06,8.47023449244571e-09,5.835735182568053e-06,5.855126858925417e-06,5.8390107655166625e-06,5.845125495648847e-06,149 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,return/bounded/k-100,4.4692508039819034e-05,4.7251995989055796e-08,4.465190845277765e-05,4.4746047824396605e-05,4.467401901676663e-05,4.471034972014883e-05,108 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,return/mean-recurrence,7.014913925169302e-05,7.416445961488493e-08,7.009437659259052e-05,7.02317102011736e-05,7.013069087088545e-05,7.018788453656701e-05,99 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,simulation/10000,0.006056055520765628,2.3615329019682427e-05,0.006028361711711251,0.006074812735183171,0.0060387809905726245,0.006064666262029768,38 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,simulation/100000,0.06105942137643676,0.00018283812468802493,0.060968550562652775,0.06143928124947706,0.060939075374855226,0.061527562502305955,12 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,stationary,6.843535106547522e-05,6.145400246153213e-08,6.838304180095008e-05,6.855305114379946e-05,6.84180827192904e-05,6.84626753475944e-05,99 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,structure/classes-cold,1.101507322956586e-05,1.3906565960888552e-08,1.1003211771170542e-05,1.1034725033893501e-05,1.1011901008923331e-05,1.1019249780618244e-05,136 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,structure/classes-lifecycle,0.00015695361062752948,1.0817334382860961e-07,0.00015688293668752882,0.00015707703474857897,0.00015692423056082539,0.00015701025528045895,108 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,structure/classes-warm/access,8.567775977545169e-09,6.116481442979118e-11,8.52599967846169e-09,1.074219350509035e-08,8.544129758564755e-09,8.631293611745686e-09,309 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,structure/classes-warm/consumed,2.3353547957326565e-07,1.2866239133252256e-09,2.324122766771631e-07,2.4004414393278086e-07,2.3306955709204015e-07,2.3401778914463358e-07,241 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,structure/irreducible-cold,5.37503588154522e-06,3.044461635460676e-08,5.356848519256967e-06,5.998620035602961e-06,5.3653102550453626e-06,5.4144197764593146e-06,151 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,structure/irreducible-warm,9.615672070195642e-09,9.056608238181854e-11,9.534011634933645e-09,1.194791791121878e-08,9.575350503254094e-09,9.691752011983267e-09,307 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,visits/bounded-expectation/k-10,8.283516790746063e-06,1.9284022179187096e-08,8.267819149370041e-06,8.311112141130612e-06,8.276542518467306e-06,8.289824383312143e-06,142 +dtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,visits/bounded-expectation/k-100,6.372097563446369e-05,5.635087593327593e-08,6.367971012919771e-05,6.378859176981712e-05,6.37107915708282e-05,6.373858394395617e-05,101 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,construction/public-consumed,0.00014493662933818996,1.3796260430552613e-07,0.00014479561893191809,0.00014503450544115396,0.00014488497598397874,0.0001449817144169415,109 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,evolution/k-10,4.396706551295544e-06,8.054939027814966e-09,4.390063584148092e-06,4.412427974245274e-06,4.395069156931347e-06,4.397957950996408e-06,181 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,evolution/k-100,2.0596832226384558e-05,3.4475876116920614e-08,2.0574244337697004e-05,2.0697518333758194e-05,2.058782926606828e-05,2.0610907464362468e-05,149 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,evolution/one-step,7.497373293448664e-07,1.508512696410996e-08,7.344207940486275e-07,7.589285592168417e-07,7.381120181433058e-07,7.512372591872147e-07,217 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,finite-time/n-step/k-10,5.758816897328025e-06,5.8723955398542275e-08,5.718171543641667e-06,6.369422548092329e-06,5.74411008711566e-06,5.878347720483264e-06,149 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,finite-time/n-step/k-100,4.331780483661187e-05,4.60653567680687e-08,4.327859498701308e-05,4.337343078416399e-05,4.3303726752955384e-05,4.333776977688401e-05,108 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,finite-time/observation/k-10,7.174592273137004e-06,1.7775660826551132e-08,7.160662702166935e-06,7.20151531030856e-06,7.16949449433537e-06,7.181361784855003e-06,145 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,finite-time/observation/k-100,4.4749947207503975e-05,4.2106660586660954e-08,4.470971922303405e-05,4.479771098723555e-05,4.4734311618722636e-05,4.4773168865703863e-05,108 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,finite-time/step,8.41902106216964e-07,1.1517943381795432e-08,8.314632901197506e-07,8.552267670151177e-07,8.397417751928934e-07,8.465712963943444e-07,189 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,hitting-probability/cold-all-states,0.00010386985873259201,1.0260436797777581e-07,0.00010377699672181221,0.00010399978072666449,0.00010380939389634337,0.00010389278209566427,92 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,hitting-probability/warm-lookup,2.3855361534049946e-08,2.8239466296680194e-10,2.359321198443843e-08,2.744782919770094e-08,2.370960639215083e-08,2.4183497700069616e-08,288 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,hitting-time/cold-all-states,9.887581290193743e-05,8.441324325459212e-08,9.88100327819262e-05,9.902149108361649e-05,9.884636915378296e-05,9.89256591496583e-05,92 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,hitting-time/warm-lookup,2.4152753228150848e-08,3.237270534637526e-10,2.3859873343712284e-08,2.8252986669610766e-08,2.3923834133461277e-08,2.4489471070758462e-08,287 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,hitting/bounded/at-most/k-10,6.755038163693796e-06,1.5744396290925555e-08,6.740626551734774e-06,6.771491343954238e-06,6.751239596076593e-06,6.758957403256371e-06,146 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,hitting/bounded/at-most/k-100,4.569833117939435e-05,4.2796842496463817e-08,4.566217837693907e-05,4.575165979297046e-05,4.568766273380356e-05,4.5715820825924834e-05,107 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,hitting/bounded/exact/k-10,6.7004400721599824e-06,1.1263262437276667e-08,6.691683998736219e-06,6.733480759587465e-06,6.6963177944372356e-06,6.705617688310949e-06,147 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,hitting/bounded/exact/k-100,4.5727373711838606e-05,4.285821326005773e-08,4.568442126980353e-05,4.576912741069108e-05,4.570840543170494e-05,4.574080675310041e-05,107 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,hitting/bounded/greater-than/k-10,6.7122161715938635e-06,1.0258051271555492e-08,6.705036431930877e-06,6.7291757872299485e-06,6.710286553324394e-06,6.718391071332513e-06,147 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,hitting/bounded/greater-than/k-100,4.559168512978166e-05,2.550117568534424e-08,4.5570559120404603e-05,4.563037319989551e-05,4.558119128392846e-05,4.5600533954829215e-05,107 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,power/10,4.718400865189127e-05,1.766754179301214e-07,4.706436273619437e-05,4.7599300457050606e-05,4.714148243576763e-05,4.728533862868937e-05,131 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,power/100,5.714193839989805e-05,1.7602263910127311e-07,5.703217435493487e-05,5.750244276548702e-05,5.7091080563159645e-05,5.721343978670892e-05,128 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,power/2,4.03841005553941e-05,3.3545352236776156e-08,4.0351677397913973e-05,4.041888685331074e-05,4.0373527540802554e-05,4.0397704331408504e-05,135 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,race/forward-committor,9.898091184853652e-05,2.497789617478106e-07,9.875562772863433e-05,9.92549914366962e-05,9.886972470087049e-05,9.907651945965305e-05,92 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,return/bounded/k-10,5.8561998477213975e-06,2.454007637739642e-08,5.830887567169782e-06,5.879671184145191e-06,5.846544412572394e-06,5.865536635685912e-06,150 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,return/bounded/k-100,4.474313438037368e-05,6.07468996422281e-08,4.467804524601108e-05,4.4799887594611703e-05,4.4727966982267195e-05,4.4756212714072074e-05,108 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,return/mean-recurrence,7.012455277167513e-05,1.4930809763975513e-07,7.001810426070159e-05,7.137506734014679e-05,7.004602536510088e-05,7.019838016103244e-05,97 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,simulation/10000,0.006122574178981058,1.9015421883837157e-05,0.006106239679146793,0.006144176369465034,0.006109176021496217,0.006132333245385245,38 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,simulation/100000,0.06208509020931767,9.03714068651168e-05,0.06200201990213827,0.06216144040891694,0.06199471880245255,0.062171658485705404,12 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,stationary,6.820785330645954e-05,7.229554021837828e-08,6.815130896178394e-05,6.831265103481774e-05,6.818388390135678e-05,6.82300781608199e-05,99 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,structure/classes-cold,1.1089681147203978e-05,1.7161099655152925e-08,1.1067086455537056e-05,1.110425446108902e-05,1.1083263017465933e-05,1.1093876932031218e-05,136 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,structure/classes-lifecycle,0.0001571393392251995,1.3089071309469868e-07,0.00015701684065834724,0.00015728588797078702,0.00015708057573495695,0.00015718190921801945,108 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,structure/classes-warm/access,8.645756944885555e-09,1.2635140952980734e-10,8.527759053276466e-09,1.1075941604102337e-08,8.57830055592454e-09,8.707135688326596e-09,309 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,structure/classes-warm/consumed,2.3468956158272234e-07,2.3702405384064984e-09,2.324882423131089e-07,2.3930096603204716e-07,2.338908816912334e-07,2.365970035003165e-07,241 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,structure/irreducible-cold,5.300267355195925e-06,1.4101276886951463e-08,5.289712702728946e-06,5.325024459417482e-06,5.297298033222255e-06,5.304438673192635e-06,151 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,structure/irreducible-warm,9.559308649165833e-09,7.995891341823424e-11,9.490488954073028e-09,1.1866235201644472e-08,9.526241211574867e-09,9.637289431385325e-09,307 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,visits/bounded-expectation/k-10,8.338746468595402e-06,2.7955430348663205e-08,8.311658764569254e-06,8.367607823005164e-06,8.329456674311168e-06,8.34902472082096e-06,142 +dtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,visits/bounded-expectation/k-100,6.399492386240108e-05,4.640002967718176e-08,6.393462704943739e-05,6.403188415083007e-05,6.397854716815805e-05,6.400336990208631e-05,100 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,construction/public-consumed,0.0005856032691260899,4.521647717228112e-07,0.000584992296622928,0.000585959284101343,0.0005852680333191529,0.0005857673293687427,81 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,evolution/k-10,1.0144474290345616e-05,1.3827325679244717e-08,1.0134180305782212e-05,1.0165464311909232e-05,1.0142982548563858e-05,1.0146377982226484e-05,164 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,evolution/k-100,9.476718402476374e-05,1.0875115792904975e-07,9.468302428499306e-05,9.489677311728655e-05,9.474177420964123e-05,9.479719113312503e-05,118 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,evolution/one-step,1.6163202670281107e-06,1.2263426601725395e-08,1.6048692242072379e-06,1.6342797442286444e-06,1.6064403078563753e-06,1.6191955315723513e-06,202 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,finite-time/n-step/k-10,1.1879000193138997e-05,2.3686893135642243e-08,1.185821448717582e-05,1.190996562729924e-05,1.1871943708591729e-05,1.1888739520569063e-05,135 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,finite-time/n-step/k-100,9.737861422482161e-05,7.678462865759613e-08,9.73175556670951e-05,9.749057435807404e-05,9.736289688802649e-05,9.741601822603104e-05,92 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,finite-time/observation/k-10,1.4405463074441426e-05,3.122165249218289e-08,1.4383153773535403e-05,1.4442734551339464e-05,1.4401526630104844e-05,1.4413267447483352e-05,131 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,finite-time/observation/k-100,9.942409021525897e-05,6.980591532229955e-08,9.937367581767153e-05,9.950764478763288e-05,9.941347909463932e-05,9.945657426938957e-05,91 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,finite-time/step,8.763648414363464e-07,1.101803289968606e-08,8.688819235158291e-07,8.927094482499301e-07,8.735306091211011e-07,8.782860407206629e-07,185 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,hitting-probability/cold-all-states,0.0003094993223838651,3.54773458844461e-07,0.0003092523177340168,0.00030993863252991684,0.00030939174346944097,0.00030966681329624003,68 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,hitting-probability/warm-lookup,2.3758665635938298e-08,1.4437722547302263e-10,2.3635827714205137e-08,2.6945954665452953e-08,2.3694291285642317e-08,2.393417836672201e-08,288 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,hitting-time/cold-all-states,0.00030067990982471116,2.6136529578991725e-07,0.00030045363908154995,0.0003010373273317949,0.00030062498128633874,0.00030079169058202143,69 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,hitting-time/warm-lookup,2.5699850670059902e-08,1.7900844506870259e-09,2.3925244059589012e-08,2.98190540848683e-08,2.4980647676966632e-08,2.6067385531508117e-08,288 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,hitting/bounded/at-most/k-10,1.5532798198836305e-05,1.4350207561564937e-07,1.541693004915809e-05,1.5737797824623293e-05,1.5476230767643136e-05,1.566885184729472e-05,129 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,hitting/bounded/at-most/k-100,0.0001046631065976696,1.187096654314422e-07,0.00010456327520865673,0.0001049138962559015,0.00010461305337703598,0.00010471493465780852,90 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,hitting/bounded/exact/k-10,1.535495315844552e-05,5.165756399397133e-08,1.532016505410716e-05,1.542532205137306e-05,1.5344610126577788e-05,1.537474963697605e-05,129 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,hitting/bounded/exact/k-100,0.00010509530472254443,8.53946166605778e-07,0.00010439436015363561,0.00010632648101650005,0.00010472983414627293,0.0001054803153693891,90 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,hitting/bounded/greater-than/k-10,1.5554357934674688e-05,6.154137261133661e-08,1.5521263321716106e-05,1.6861131492381294e-05,1.5539619052038846e-05,1.5635625554364346e-05,129 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,hitting/bounded/greater-than/k-100,0.00010459763958351687,1.3376956943561585e-07,0.00010449249051237306,0.00010480553265805191,0.00010455154510218816,0.00010466266487701376,90 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,power/10,0.00016522661290148407,1.3949183185521085e-07,0.00016508642580439006,0.00016536552837758105,0.0001651859630945048,0.00016527777276650971,107 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,power/100,0.00020635127537623206,2.9902967492398153e-07,0.00020605940866130258,0.00020664913332540084,0.00020624949392506302,0.0002064583346229763,102 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,power/2,0.00013293949680733152,8.733836270104515e-08,0.00013287364104015064,0.00013314062140458807,0.00013291304344750023,0.0001329717541905712,111 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,race/forward-committor,0.0002832570310286484,2.2742509305070848e-07,0.00028307490352449965,0.000283715236441944,0.00028316004757052436,0.00028341160932062565,70 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,return/bounded/k-10,1.2247550327933245e-05,2.7529450798239666e-08,1.2225407158509733e-05,1.2281961102828258e-05,1.2241576369715344e-05,1.2256290010911613e-05,134 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,return/bounded/k-100,0.000100843509068925,8.007542387451555e-08,0.00010076381845051814,0.00010092324412582797,0.0001008041336286911,0.00010086506881634705,91 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,return/mean-recurrence,0.0004361953502666438,3.628516424214142e-07,0.00043583811426427786,0.00043655820190906524,0.0004360196109366964,0.00043634576580556543,65 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,simulation/10000,0.00611440302179997,1.0344028168462159e-05,0.0061050845203711075,0.006125997829809831,0.006110477361383374,0.006119149194543301,38 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,simulation/100000,0.06090614171296779,0.00016411927076247224,0.060675474001982366,0.06100942963828195,0.06066782299967599,0.06101007427412586,12 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,stationary,0.0004322572985984152,2.649867383297533e-07,0.00043205053641161485,0.0004325691725751583,0.0004321451113490319,0.00043238371325895895,65 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,structure/classes-cold,2.0691599624538884e-05,4.447826563679216e-08,2.0656082082667157e-05,2.0755687459258763e-05,2.06835296860467e-05,2.0705599066180488e-05,123 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,structure/classes-lifecycle,0.0006097543575862745,2.1463206905756736e-06,0.0006078562357671265,0.0006125810767583515,0.0006086179845056967,0.000611439592193224,80 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,structure/classes-warm/access,8.672707778562602e-09,1.5633703030888506e-10,8.524556528470375e-09,1.0928965448478206e-08,8.606942579377918e-09,8.725970390578102e-09,309 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,structure/classes-warm/consumed,4.891212150750019e-07,1.4134415112740095e-09,4.879640175659017e-07,4.993420870745749e-07,4.887401384741449e-07,4.899854127564435e-07,226 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,structure/irreducible-cold,9.688302383732956e-06,1.8622624487669935e-08,9.673860922488725e-06,9.713909750436576e-06,9.683261046827762e-06,9.696535951671835e-06,139 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,structure/irreducible-warm,9.660196090431939e-09,1.421470755324337e-10,9.5308790609398e-09,1.207008467551376e-08,9.605353469448346e-09,9.790009549041575e-09,307 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,visits/bounded-expectation/k-10,1.5143257128484368e-05,3.314270854530633e-08,1.5112325513210306e-05,1.5191999838347956e-05,1.5132979206100572e-05,1.5154241654665678e-05,130 +dtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,visits/bounded-expectation/k-100,0.00012458584961043954,2.0974613321804686e-07,0.00012441454505449654,0.00012484843760885822,0.00012452260792273487,0.00012466973189643964,87 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,construction/public-consumed,0.0005912995714295123,4.132907748882904e-06,0.0005881419933996911,0.000595978946113328,0.0005899018987396561,0.0005932916246820241,81 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,evolution/k-10,1.0099140393237052e-05,1.2640440600862985e-08,1.0088739654134262e-05,1.0115831380992447e-05,1.0097373964034024e-05,1.0102760901448436e-05,164 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,evolution/k-100,9.487124862909639e-05,8.564852058076677e-08,9.478926574817947e-05,9.496035967178386e-05,9.485962855837303e-05,9.48953732926377e-05,118 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,evolution/one-step,1.6178335176238825e-06,1.3672117840748644e-08,1.6057817109347626e-06,1.640233475059408e-06,1.615175499834596e-06,1.6202497090621538e-06,202 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,finite-time/n-step/k-10,1.186724419052187e-05,3.98513085528798e-08,1.1832110657582191e-05,1.1914287962812437e-05,1.1849237558808887e-05,1.188968242045693e-05,135 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,finite-time/n-step/k-100,9.848457569222433e-05,6.593983291043148e-07,9.778231934470318e-05,9.906292194373058e-05,9.821471857308559e-05,9.867171481456846e-05,92 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,finite-time/observation/k-10,1.4427157632168968e-05,3.6694151641421274e-08,1.4397665136025597e-05,1.4514875142842237e-05,1.4418379786158246e-05,1.4440231690041758e-05,131 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,finite-time/observation/k-100,0.0001000080440382037,1.195451578853363e-07,9.991557883204632e-05,0.00010014767755083518,9.996484704270888e-05,0.00010004519555088405,91 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,finite-time/step,8.778476766605375e-07,1.1455837791349489e-08,8.682889909016438e-07,8.961993751981798e-07,8.74922084802888e-07,8.816797123049314e-07,188 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,hitting-probability/cold-all-states,0.0003095857453603378,9.361287103168382e-07,0.0003089103661172762,0.00031674650017521344,0.0003091748022772806,0.0003103300921132111,68 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,hitting-probability/warm-lookup,2.393636683910488e-08,3.027958354799062e-10,2.3714420843108523e-08,2.7023761421216128e-08,2.3844792127976566e-08,2.407271508967481e-08,288 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,hitting-time/cold-all-states,0.00030351647288778317,2.331375574257514e-06,0.00030140939944195216,0.000306562491459772,0.0003027738525166309,0.0003047976195895379,69 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,hitting-time/warm-lookup,2.458718110998441e-08,6.741281582573688e-10,2.3990804454983172e-08,2.7520421747912205e-08,2.4479128261015e-08,2.4893306716853157e-08,288 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,hitting/bounded/at-most/k-10,1.541889612685497e-05,3.170811357863123e-08,1.539008344816803e-05,1.5458333604201152e-05,1.5414126830855533e-05,1.543020885729963e-05,129 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,hitting/bounded/at-most/k-100,0.00010469172231326017,8.871123805489112e-08,0.00010461563258066904,0.00010479065849280745,0.00010467099703722245,0.00010472382549107944,90 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,hitting/bounded/exact/k-10,1.5434677330947153e-05,2.519457132148806e-08,1.5410670634371444e-05,1.546512637626452e-05,1.5425661583251963e-05,1.5440033683253545e-05,129 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,hitting/bounded/exact/k-100,0.00010392269082405589,7.936250453781846e-08,0.00010385045022525605,0.00010402337562318375,0.00010388687050401262,0.00010394501462713748,91 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,hitting/bounded/greater-than/k-10,1.552339509420369e-05,2.8067684259693395e-08,1.550001089375049e-05,1.5554508633837374e-05,1.551657285003299e-05,1.5531850049403802e-05,129 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,hitting/bounded/greater-than/k-100,0.00010456615597339284,9.461285420305767e-08,0.00010446385646656736,0.00010464900913136871,0.00010451970254153475,0.00010459500964826894,90 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,power/10,0.0001654020213641823,3.659048897190103e-07,0.00016520751450142,0.00016680609348570992,0.00016534277182283355,0.0001655090225253485,107 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,power/100,0.0002264665818593503,1.9321207330500397e-05,0.00020800077699485717,0.00025200379505384296,0.00021263614414945348,0.00024042834948517794,100 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,power/2,0.00013271799273923904,6.444400484987276e-08,0.00013265905931002546,0.00013279391155911904,0.00013269347245607136,0.0001327495931535868,111 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,race/forward-committor,0.0002828159174983046,2.250201153704886e-07,0.00028262973869963456,0.00028315354829513745,0.00028271677947591743,0.00028297281655334473,70 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,return/bounded/k-10,1.2287090597739595e-05,2.402580344520963e-08,1.2262910322407399e-05,1.231012100722597e-05,1.2281145828336343e-05,1.2291705506365225e-05,134 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,return/bounded/k-100,0.00010177654006374662,8.48939969939845e-07,0.00010102493564676784,0.00010704605538370902,0.00010114073571461514,0.00010227114683591524,91 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,return/mean-recurrence,0.0004372312667934845,3.4899300468775856e-07,0.00043688227378879674,0.0004374696826826866,0.0004370624167980471,0.00043735503917559983,65 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,simulation/10000,0.006113817525679392,1.2795115724186651e-05,0.0061000487262408785,0.006123493186623819,0.006106631472067246,0.006118478601066662,38 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,simulation/100000,0.06083880549865878,0.0001763839639482151,0.0606116691669134,0.06094695245743165,0.060602796834306596,0.0609557381140933,12 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,stationary,0.00043330546468496324,4.013860321027394e-07,0.00043297903246111084,0.0004340553347165475,0.0004331142036891025,0.00043356260139262306,65 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,structure/classes-cold,2.1806077991361515e-05,1.178120522791584e-07,2.172385920206277e-05,2.1974367892770843e-05,2.1769473438753802e-05,2.187563745209422e-05,123 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,structure/classes-lifecycle,0.0006225572524272138,7.558693281540531e-06,0.000615613367200619,0.0006311877091427638,0.0006204870506275248,0.0006244809322243643,80 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,structure/classes-warm/access,8.631827752353668e-09,1.1385178953214115e-10,8.531581520980226e-09,1.0775902305847441e-08,8.584913579112456e-09,8.728526207696457e-09,309 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,structure/classes-warm/consumed,5.172067836449064e-07,9.626666126174653e-09,5.136504930468424e-07,5.296641931003567e-07,5.167207953424848e-07,5.184842085143939e-07,226 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,structure/irreducible-cold,9.805255083589034e-06,2.045002331101666e-08,9.788526947382539e-06,9.831004044590608e-06,9.802473797717299e-06,9.811420520571501e-06,139 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,structure/irreducible-warm,9.607129539675498e-09,9.172142502999627e-11,9.529978547185739e-09,1.2206849097398887e-08,9.587399210775678e-09,9.693393511046975e-09,307 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,visits/bounded-expectation/k-10,1.526278106409692e-05,1.6368360893776252e-07,1.5123395506203738e-05,1.544916955172454e-05,1.5210912573190058e-05,1.5314599295379594e-05,130 +dtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,visits/bounded-expectation/k-100,0.00012468906492426026,1.1626549099605994e-07,0.0001245682433021307,0.0001247927734766563,0.00012464842547707422,0.00012472985005739653,87 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,construction/public-consumed,0.0005858750000183101,4.02358695498475e-07,0.0005853001480486624,0.0005862078798172711,0.0005857285063421277,0.0005860381588888154,81 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,evolution/k-10,1.0142402287336319e-05,1.3284053039973188e-08,1.013045478140421e-05,1.015978796175947e-05,1.0139967055003217e-05,1.0145383963552571e-05,164 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,evolution/k-100,9.513411788133095e-05,1.0046520940559372e-07,9.50573191531267e-05,9.530946265116284e-05,9.51163134291801e-05,9.515000001556473e-05,118 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,evolution/one-step,1.610590585673318e-06,9.879657573834123e-09,1.6038221452604317e-06,1.6366573463684187e-06,1.6054762288303713e-06,1.6199641415226608e-06,202 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,finite-time/n-step/k-10,1.1881595547107027e-05,2.7770955397334434e-08,1.1860678032659921e-05,1.1916286230028695e-05,1.1870644907742788e-05,1.1890702623624247e-05,135 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,finite-time/n-step/k-100,9.74742708115837e-05,7.283376121971477e-08,9.739813794523543e-05,9.753847618073208e-05,9.746028096439356e-05,9.749387685219977e-05,92 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,finite-time/observation/k-10,1.4428020872166185e-05,3.20697580576972e-08,1.440026441754139e-05,1.4476455733896147e-05,1.4415217135267864e-05,1.4439131758224807e-05,131 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,finite-time/observation/k-100,0.0001000943089642335,1.2349959371415494e-07,9.997155000477908e-05,0.00010021617848899583,0.00010002153162315066,0.0001001414859370255,90 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,finite-time/step,8.823904819274071e-07,1.4288623273111307e-08,8.717291309853624e-07,9.072758155739661e-07,8.77325557216352e-07,8.888171193347217e-07,188 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,hitting-probability/cold-all-states,0.00030881373257812925,3.179290312497747e-07,0.0003085416556132259,0.0003092657391051834,0.0003086511742966361,0.0003089649336206176,68 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,hitting-probability/warm-lookup,2.37346680052003e-08,1.1389706515985787e-10,2.36394348927881e-08,2.680409614605686e-08,2.3687331893817378e-08,2.3876665141914542e-08,288 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,hitting-time/cold-all-states,0.00030028240656031777,3.7680804746705694e-07,0.000300008399894328,0.0003007401058934384,0.00030013248376715713,0.0003004148780672374,69 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,hitting-time/warm-lookup,2.4022701104632633e-08,1.3340806999525048e-10,2.3914388359547996e-08,2.7387716495785982e-08,2.396200386912315e-08,2.421279264161427e-08,288 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,hitting/bounded/at-most/k-10,1.5581763907190165e-05,1.0569292245780527e-07,1.5490618594754365e-05,1.573701301822439e-05,1.5543474050596083e-05,1.562763222276019e-05,129 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,hitting/bounded/at-most/k-100,0.00010460163578695405,1.2405542074318403e-07,0.00010446507335616748,0.0001047090309120713,0.00010456302341341626,0.00010463008330782921,90 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,hitting/bounded/exact/k-10,1.5430832019729538e-05,3.4664696937624506e-08,1.5396717407706855e-05,1.547769016514604e-05,1.5419528379064862e-05,1.5437710774658387e-05,129 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,hitting/bounded/exact/k-100,0.00010461626354174176,3.9259850257029725e-07,0.00010433157469953201,0.0001053596257879273,0.00010451731254256124,0.00010490482756202775,90 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,hitting/bounded/greater-than/k-10,1.5549718923664286e-05,2.767154546938773e-08,1.5530892821799923e-05,1.559328055009246e-05,1.554440207984139e-05,1.5558250192701855e-05,129 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,hitting/bounded/greater-than/k-100,0.00010454780827583916,1.0298665089900283e-07,0.00010444334903413305,0.00010464529587179893,0.00010450779747875962,0.00010458169543555161,90 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,power/10,0.00016618859642716287,1.3756274562176456e-07,0.0001660727831439488,0.0001663429926568303,0.00016615263273112705,0.00016623259518362666,107 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,power/100,0.00020789086022568627,4.0216973775713475e-07,0.00020753780008544276,0.0002083701999240936,0.00020777109307893056,0.00020795161306244743,102 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,power/2,0.00013343632722498858,1.0610490227953265e-07,0.0001333631280865403,0.00013359344428762497,0.00013340198511873643,0.0001334732140613986,111 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,race/forward-committor,0.0002829012925739014,2.453301292488976e-07,0.0002826958891907353,0.0002832675490660194,0.00028283582135281676,0.0002830324062345496,70 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,return/bounded/k-10,1.2321062883697133e-05,7.64091018010379e-08,1.2268203057474001e-05,1.2477119573481761e-05,1.2300530753277022e-05,1.2388647189906917e-05,134 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,return/bounded/k-100,0.00010087693029324846,1.120758396778418e-07,0.00010077449785048602,0.00010102060049474757,0.00010083389582813315,0.00010093101805161532,91 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,return/mean-recurrence,0.00043733687057430224,3.622772664181118e-07,0.0004370285089846635,0.0004377612706527791,0.0004371072762296535,0.00043752328817320697,65 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,simulation/10000,0.006123689637140647,1.4959092368371785e-05,0.006109645851251521,0.006141051155767248,0.006114512202614043,0.0061334140672817524,36 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,simulation/100000,0.06080853491585003,0.0001636051549991982,0.06060469907849134,0.06089049171454722,0.06059619760829567,0.06090713142925995,12 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,stationary,0.0004330610006166223,2.2700008510829475e-07,0.0004328665345030141,0.000433299463582915,0.00043293685471787507,0.00043313893450734516,65 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,structure/classes-cold,2.1492680847770026e-05,3.1955216547390847e-08,2.1462375301531045e-05,2.154194735339843e-05,2.1479757302484223e-05,2.1502658243867174e-05,123 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,structure/classes-lifecycle,0.0006124607283221125,1.8919777597333257e-06,0.000611412954583232,0.0006155386365258775,0.000611633333513358,0.0006147144819576159,80 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,structure/classes-warm/access,8.564190414087434e-09,8.113123845305216e-11,8.493886536214947e-09,1.0775860489999084e-08,8.53499920338234e-09,8.65045377651099e-09,309 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,structure/classes-warm/consumed,4.873515644778934e-07,1.1787212331766632e-09,4.863344448737591e-07,5.033563527576535e-07,4.868536770397505e-07,4.879522899779715e-07,226 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,structure/irreducible-cold,9.66983725296711e-06,4.3568592986897026e-08,9.621756501190404e-06,9.707681332202673e-06,9.647348485538264e-06,9.683978026481093e-06,139 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,structure/irreducible-warm,9.696748464880024e-09,1.8155803108334237e-10,9.529286575080014e-09,1.1950804968074345e-08,9.612288363093171e-09,9.761208430344566e-09,307 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,visits/bounded-expectation/k-10,1.5202369094867294e-05,4.477680629687056e-08,1.5157663055465297e-05,1.524673814194764e-05,1.518339947021256e-05,1.521286170221477e-05,130 +dtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,visits/bounded-expectation/k-100,0.00012475323176029354,1.3025794312572156e-07,0.00012462590031868693,0.00012487752746719364,0.0001247172913281247,0.00012478850885885972,87 +dtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,construction/public-consumed,0.005186703216522677,3.386872295257177e-05,0.005149294739879093,0.005215619822466445,0.005163706872783758,0.005206366955422304,40 +dtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,evolution/k-10,7.592075633487806e-05,6.410707564376652e-08,7.586201848295917e-05,7.599481024115256e-05,7.589030606976274e-05,7.593750000307752e-05,123 +dtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,evolution/k-100,0.0007437088223483453,6.885968650749332e-07,0.0007430481753988838,0.0007444094390090565,0.0007432286426447483,0.0007440043815509661,76 +dtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,evolution/one-step,9.137441767539697e-06,6.717294064102316e-08,9.081235322749102e-06,9.486849674016731e-06,9.107085975057254e-06,9.166930857811522e-06,165 +dtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,hitting-probability/cold-all-states,0.0017268169907299288,5.563916091064322e-06,0.001722440887189785,0.0017487241257185815,0.0017232227388455574,0.0017323570001670824,32 +dtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,hitting-probability/warm-lookup,2.3977337148881706e-08,3.6122051455026566e-10,2.363826482044402e-08,2.803369389667358e-08,2.3773208015165705e-08,2.4431585663463755e-08,288 +dtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,hitting-time/cold-all-states,0.001702391701110173,1.5933319622080848e-06,0.0017014414873513563,0.0017052787541064335,0.0017017962503208157,0.0017038278640635932,34 +dtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,hitting-time/warm-lookup,2.4378612998148825e-08,4.809408922982542e-10,2.3916055473785326e-08,2.7570400109240142e-08,2.4005762397281706e-08,2.468062150008738e-08,288 +dtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,power/10,0.0011421880730510983,1.3744127303090916e-05,0.001127249069638007,0.0011482789748662142,0.0011306865001513091,0.00114537668708488,68 +dtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,power/100,0.0015986666662178726,1.781247869479959e-05,0.0015832611330552026,0.0016168090237659357,0.0015929698510011262,0.0016085987394830182,61 +dtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,power/2,0.0008147694108679202,1.2736010472035085e-05,0.0007972088134377835,0.0008202766220306843,0.0008097511062767373,0.0008173160357338409,75 +dtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,race/forward-committor,0.0015734582683459544,3.0454571859799603e-06,0.0015708844946227775,0.0015777406442091025,0.001571991795208305,0.0015760278895161012,35 +dtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,return/mean-recurrence,0.006399585215030643,9.701914013534978e-06,0.0063896855048629474,0.006407501062413858,0.006389883301017108,0.0064064165410606866,27 +dtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,simulation/10000,0.006266750168530659,2.7420380447242508e-05,0.006237713294788538,0.006292302699876018,0.006254177481255114,0.006283575819741765,37 +dtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,simulation/100000,0.06141216998003074,2.9257473388930033e-05,0.06140560633660546,0.061556315135627905,0.06140221255829803,0.06162128886838521,12 +dtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,stationary,0.006386852459399961,6.273755894249319e-06,0.006381178146887882,0.006394986787745438,0.006381555664120242,0.006391497895636253,27 +dtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,structure/classes-cold,6.451143511940452e-05,5.281837017531558e-07,6.407301946473247e-05,6.516917371958169e-05,6.438009167499276e-05,6.473394733612586e-05,100 +dtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,structure/classes-lifecycle,0.0052868401788146,2.28104786001845e-05,0.0052727217946873794,0.005316935842556907,0.0052782810426891804,0.005306510207521235,40 +dtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,structure/classes-warm/access,8.642831048965802e-09,1.2671753659529022e-10,8.528624210046275e-09,1.1168638768841524e-08,8.589464278602235e-09,8.702951543224058e-09,309 +dtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,structure/classes-warm/consumed,1.2554568625367678e-06,2.317818514108139e-09,1.2539968492503265e-06,1.2666310972778335e-06,1.2549092648172517e-06,1.2564615946196308e-06,207 +dtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,structure/irreducible-cold,2.7130961856775047e-05,2.1811555462959447e-07,2.693834676241866e-05,2.7436538395927e-05,2.7057221394408352e-05,2.7213194138871935e-05,118 +dtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,structure/irreducible-warm,9.693921093477211e-09,1.6838145129497962e-10,9.5444030733932e-09,1.2603204999141343e-08,9.607418852216495e-09,9.85208338702106e-09,307 +dtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,construction/public-consumed,0.005176662879411769,3.91850044158034e-05,0.005138028409253986,0.005218963236192423,0.005152690759172361,0.005200773981193903,40 +dtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,evolution/k-10,7.587679682358165e-05,7.206701699562657e-08,7.581713061930001e-05,7.59634469717128e-05,7.586014843804554e-05,7.589770450676454e-05,123 +dtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,evolution/k-100,0.0007436475682769089,5.766024840687814e-07,0.0007431425273841198,0.0007447030959351942,0.000743434214276461,0.000743882567805117,76 +dtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,evolution/one-step,9.084740012972985e-06,3.558973667641019e-08,9.055071873470179e-06,9.184922013548706e-06,9.063934620707349e-06,9.100358831492002e-06,166 +dtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,hitting-probability/cold-all-states,0.0017222085524634975,3.7960762037309633e-06,0.0017173055253113575,0.0017252290817850735,0.0017193222340817253,0.00172479163340636,33 +dtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,hitting-probability/warm-lookup,2.3856475322864605e-08,2.359003869283999e-10,2.3639678188287035e-08,2.7337070750778457e-08,2.3770866469892734e-08,2.4040354479326395e-08,288 +dtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,hitting-time/cold-all-states,0.0017038278903130095,2.0500124008276206e-06,0.0017016194483709085,0.0017056307015908797,0.0017028038256445572,0.00170522481379234,34 +dtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,hitting-time/warm-lookup,2.429930801008563e-08,4.077364900308687e-10,2.3940861827932518e-08,2.8770688588552234e-08,2.4121938418306757e-08,2.4677349578499113e-08,286 +dtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,power/10,0.001140898502882579,1.217025053779487e-05,0.001124190261297401,0.0011489304061392937,0.00113314451999262,0.0011459643584266072,68 +dtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,power/100,0.0015958193320003043,1.8674741970721724e-05,0.0015774487776521017,0.0016155209106641234,0.0015902410188162717,0.001607692187462817,62 +dtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,power/2,0.000814418585593414,1.2779162966857003e-05,0.000795281400184779,0.0008204735664052846,0.000807014002930373,0.0008163173560990812,75 +dtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,race/forward-committor,0.0015694847373340867,2.935559445505463e-06,0.0015659948218195948,0.0015710084582441714,0.0015671393490405395,0.0015698841102507518,35 +dtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,return/mean-recurrence,0.006406660305891329,6.981942043729136e-06,0.006400019790210839,0.006412220281593986,0.006402180332224816,0.006409335237029674,27 +dtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,simulation/10000,0.0062848188838240905,2.7831119358248842e-05,0.006256987764465842,0.0063101856188344145,0.006274550961852247,0.006300503567099045,37 +dtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,simulation/100000,0.0616043599289476,7.837541010563207e-05,0.061564078369610795,0.06182804437750227,0.061548016113556515,0.061983599705624885,12 +dtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,stationary,0.006382689364148642,6.361278461885361e-06,0.006378717884692141,0.006389769326969621,0.006379296680679544,0.006389341089578176,27 +dtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,structure/classes-cold,6.274431705771184e-05,2.768673507073515e-07,6.250930245086137e-05,6.328542833715055e-05,6.263269336433014e-05,6.284111230424867e-05,101 +dtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,structure/classes-lifecycle,0.005286707499821767,2.7925749877448156e-05,0.00525941222495021,0.0053145058999899235,0.005266848459238341,0.005303205511515913,40 +dtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,structure/classes-warm/access,8.592234792710397e-09,1.0684860964813568e-10,8.498606813323867e-09,1.1399502308874375e-08,8.548016165423222e-09,8.751539733400542e-09,307 +dtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,structure/classes-warm/consumed,1.2540983677398963e-06,3.282759435583586e-09,1.2516802688918397e-06,1.267419019057296e-06,1.2534330436988666e-06,1.255137697402118e-06,207 +dtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,structure/irreducible-cold,2.6708405560058602e-05,2.1005535982703478e-07,2.654993584843807e-05,2.7063061307407754e-05,2.665880471247819e-05,2.6790674586652942e-05,118 +dtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,structure/irreducible-warm,9.638133456200755e-09,1.3020718613771857e-10,9.525695136993051e-09,1.1825819664458458e-08,9.600051509171984e-09,9.759579160222126e-09,307 +dtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,construction/public-consumed,0.0051934282963074195,3.991211379991092e-05,0.0051421393409847435,0.005227490916548695,0.005153854166564997,0.005216097576388221,40 +dtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,evolution/k-10,7.601072711898296e-05,8.980886820339289e-08,7.595715088324747e-05,7.63078763120914e-05,7.598991148763464e-05,7.60569235184637e-05,123 +dtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,evolution/k-100,0.0007418154789224861,5.867554128328838e-07,0.0007414166665748107,0.0007431344085332927,0.000741628763939338,0.000742169681251508,77 +dtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,evolution/one-step,9.10753093317839e-06,4.490916895235429e-08,9.067513391976639e-06,9.19914114309081e-06,9.080554013161049e-06,9.142800622554849e-06,166 +dtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,hitting-probability/cold-all-states,0.0017200292969829644,2.1353862087651696e-06,0.001718159834126709,0.0017224259976905563,0.0017188416983117349,0.0017217003058047136,33 +dtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,hitting-probability/warm-lookup,2.383616500091437e-08,2.077956398879266e-10,2.3642395358152375e-08,2.733187156865089e-08,2.3744955708789124e-08,2.396845827348939e-08,288 +dtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,hitting-time/cold-all-states,0.001704716660784917,3.0729551661734912e-06,0.001702154679131364,0.0017077920069520287,0.001703245904354844,0.0017066490751164163,34 +dtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,hitting-time/warm-lookup,2.416645549786676e-08,2.653316399512743e-10,2.3919348353443555e-08,2.7846697422624883e-08,2.406936942733791e-08,2.429024791010957e-08,288 +dtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,power/10,0.0011376686150805127,1.043821066559758e-05,0.0011205987806133895,0.0011444261076071092,0.001132990778488521,0.0011417941199742313,68 +dtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,power/100,0.001581114919807836,1.630383255006758e-05,0.00156287997963735,0.0015954390782396996,0.0015730808527421132,0.0015892327303031618,62 +dtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,power/2,0.0008127597813529381,7.769551874462171e-06,0.0007966754343908092,0.0008178153027371667,0.0008079166667206058,0.0008149388684518941,75 +dtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,race/forward-committor,0.0015760694999092568,3.791497874772176e-06,0.0015739381080780539,0.0015801569674079876,0.001574431818550114,0.001577625061145227,35 +dtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,return/mean-recurrence,0.006408699799794704,5.116598913446069e-06,0.006404764334151061,0.006421093393284883,0.0064054485864129245,0.00641426312540716,27 +dtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,simulation/10000,0.0063216341754014135,6.625384594584728e-05,0.006289169549876937,0.006983238922202872,0.006294717434565941,0.006545370337075188,36 +dtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,simulation/100000,0.061689021450971875,0.00022390976532320195,0.061595235150889494,0.06194505058695765,0.06154410580347758,0.06200043453461515,12 +dtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,stationary,0.006427568529034033,4.2122731974814434e-05,0.006385413350480597,0.006457561450952198,0.006390336742143794,0.006448638830382454,27 +dtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,structure/classes-cold,6.223974252321027e-05,2.535593781815643e-07,6.20227263866444e-05,6.263970518765356e-05,6.217536927004786e-05,6.233427053014621e-05,101 +dtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,structure/classes-lifecycle,0.005230410881631542,4.227100533300745e-05,0.005195776793119545,0.0052741976996121985,0.005205717502628649,0.005255516279359261,40 +dtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,structure/classes-warm/access,8.64594304928536e-09,1.3722480154931626e-10,8.527829746408704e-09,1.1158456308309173e-08,8.600458923155603e-09,8.72346278461688e-09,309 +dtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,structure/classes-warm/consumed,1.2604812135273347e-06,7.014621522115227e-09,1.2544516993997572e-06,1.278734021558659e-06,1.2582501352419572e-06,1.2624273302903026e-06,206 +dtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,structure/irreducible-cold,2.7078298022257304e-05,2.7339601026592295e-07,2.6865291399296028e-05,2.7621085617006972e-05,2.700729828204079e-05,2.7149715878155343e-05,118 +dtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,structure/irreducible-warm,9.677409853543407e-09,1.6762691684535162e-10,9.537034258460352e-09,1.2562569618826144e-08,9.626057712409406e-09,9.744702672503223e-09,307 +dtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,construction/public-consumed,0.028822297871992295,0.00019536137807038036,0.02869706945815172,0.029064814000906023,0.028704937500151573,0.029061919667236952,18 +dtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,evolution/k-10,0.00029822834803067675,3.4178138579878635e-07,0.0002976683860955139,0.0002985126717062369,0.00029806661184825076,0.0002983455785486482,95 +dtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,evolution/k-100,0.0029473059133665147,1.0021830448407338e-06,0.0029462879818531675,0.002948220001575024,0.0029466929825088172,0.002948008280086508,50 +dtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,evolution/one-step,3.270760711920699e-05,2.793063899362105e-08,3.268618851322883e-05,3.2760967986577095e-05,3.2699091556152274e-05,3.271759204477306e-05,140 +dtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,hitting-probability/cold-all-states,0.01168460950066219,3.680250037260517e-05,0.011654459700234425,0.01172611502739268,0.011647807000289586,0.011731950199464335,15 +dtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,hitting-probability/warm-lookup,2.381127276548417e-08,2.4135577504007605e-10,2.3596241027227843e-08,2.724398564998998e-08,2.372510289702754e-08,2.3985566896425398e-08,288 +dtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,hitting-time/cold-all-states,0.011609437500010245,2.5267929179659254e-05,0.011595475019059834,0.011655053278056065,0.011594408399347837,0.011634705429189904,15 +dtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,hitting-time/warm-lookup,2.414515678484596e-08,2.507307825194786e-10,2.3911764816632465e-08,2.756664175828517e-08,2.4069087119683327e-08,2.434527715144782e-08,288 +dtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,power/10,0.006662102311978663,6.708244094420605e-05,0.006595582851966327,0.006724005946515328,0.006602529178322259,0.006692792039024014,36 +dtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,power/100,0.011057590277535686,9.118896164102275e-05,0.010966401315894663,0.011146571428980678,0.011043181966912622,0.01112168629462009,29 +dtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,power/2,0.004145004715076265,6.606098141616942e-05,0.004092428613687474,0.004213455202410173,0.004119311878722246,0.004179059469783114,44 +dtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,race/forward-committor,0.010873344634257426,3.2178131897870124e-05,0.010850544151001555,0.010928708499704953,0.010845580001701959,0.010917979248915799,15 +dtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,return/mean-recurrence,0.05174848329843371,1.4522492913074392e-05,0.051739299402834144,0.05176361752102013,0.051732444582739845,0.05176584154307622,10 +dtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,simulation/10000,0.007068179150519427,2.0245848281775017e-05,0.007056274903641285,0.007225666720925952,0.007057998502083744,0.007196748850037693,35 +dtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,simulation/100000,0.06281896195590284,0.0005588561375083761,0.062320199603871314,0.06337731487355995,0.06229553281041768,0.06339071824859274,12 +dtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,stationary,0.05139616775237041,1.5637106116628274e-05,0.05139098884998626,0.05142383671227435,0.05138159050839022,0.05143673591737752,10 +dtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,structure/classes-cold,0.00014906938881826593,4.2846453267013254e-07,0.00014870467221752935,0.00014975709735768974,0.00014890381581213696,0.00014936449952074327,83 +dtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,structure/classes-lifecycle,0.029427772266596246,0.00024960792082613995,0.02896073950250866,0.029511541666579433,0.02896073950250866,0.029511541666579433,17 +dtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,structure/classes-warm/access,8.724942354447915e-09,2.040432746094366e-10,8.52936146322333e-09,1.1671687958829375e-08,8.660775971218757e-09,8.829803445499952e-09,309 +dtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,structure/classes-warm/consumed,2.5395769253109562e-06,7.532024640577188e-09,2.533453569552761e-06,2.57585803852699e-06,2.5362361778958396e-06,2.5452028522584403e-06,192 +dtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,structure/irreducible-cold,6.66613688457002e-05,2.6796536612658543e-07,6.639768253366103e-05,6.69342190829209e-05,6.657914543034535e-05,6.676445118500852e-05,100 +dtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,structure/irreducible-warm,9.869961884669754e-09,3.732331246064437e-10,9.506805030588291e-09,1.2429309154273399e-08,9.626554778197059e-09,1.0158196271175152e-08,307 +dtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,construction/public-consumed,0.02865188366595554,0.00012037729110693507,0.02855827474945727,0.028781465907368096,0.02858029689041635,0.02875660416854468,18 +dtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,evolution/k-10,0.00029793907565401256,3.6340216644296626e-07,0.00029734998090480945,0.0002981799665868518,0.0002976969990413636,0.000298036693162761,95 +dtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,evolution/k-100,0.002946287037048023,1.9770368817262005e-06,0.0029444708496157547,0.0029483021244232077,0.0029453373329791552,0.0029472166501363973,49 +dtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,evolution/one-step,3.27943067419114e-05,3.678423682328236e-08,3.275602144119811e-05,3.2826007880298126e-05,3.27850022226218e-05,3.2801146080597664e-05,140 +dtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,hitting-probability/cold-all-states,0.011626781501036021,5.697086536119063e-05,0.01157912426874232,0.011676827764798267,0.011588437901809811,0.011685333194327541,15 +dtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,hitting-probability/warm-lookup,2.4469237409175774e-08,8.743953112281417e-10,2.361002915914281e-08,2.784413175948419e-08,2.4254811113091618e-08,2.4602271288345247e-08,288 +dtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,hitting-time/cold-all-states,0.011597441602498293,4.3573216400825954e-05,0.011563915213628206,0.011663960636926478,0.011558723284646735,0.011683652829863908,15 +dtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,hitting-time/warm-lookup,2.415131258537078e-08,2.556610385793384e-10,2.39194684909272e-08,2.7447403744530417e-08,2.4033634391229918e-08,2.430160438256682e-08,288 +dtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,power/10,0.006643353512979382,7.411453141627613e-05,0.006566177772088977,0.006703184748035017,0.006583407738025205,0.006686134519766325,36 +dtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,power/100,0.011040463000729991,9.433111728296764e-05,0.010941558035743324,0.011125428570916742,0.010968623320222833,0.01110415966832079,29 +dtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,power/2,0.004140049450713362,7.051179101460851e-05,0.004084105960477986,0.004210313291306582,0.004117770566200563,0.00417903656231906,44 +dtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,race/forward-committor,0.010901611223946221,4.613865146691626e-05,0.010864262727149514,0.010963749836628267,0.010861718667001696,0.010947749875413137,15 +dtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,return/mean-recurrence,0.051622574463440936,8.194408560701152e-05,0.051571928853809366,0.05172523325866981,0.051566708003520034,0.05173715972382019,10 +dtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,simulation/10000,0.007173190524190432,0.00012676695793440319,0.007044899338830469,0.007281453916740637,0.007049810221091051,0.007249274153414613,35 +dtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,simulation/100000,0.06258581067999734,0.0003942682990075094,0.06231331670132931,0.06296881305282416,0.06223600000084843,0.06298007897900484,12 +dtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,stationary,0.05144766162240038,3.9510253069845874e-05,0.051412588751190924,0.0514869769289362,0.051411770999645036,0.051575789439239086,10 +dtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,structure/classes-cold,0.00014431274563927825,4.4523028854627543e-07,0.00014399352028082897,0.00014507188362006374,0.00014419170110926884,0.00014455240804971638,84 +dtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,structure/classes-lifecycle,0.029227041501144413,0.00021035135640496555,0.02908825933344714,0.02943739285754938,0.02908825933344714,0.02943739285754938,17 +dtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,structure/classes-warm/access,8.73669439386418e-09,2.2136906655058056e-10,8.537056444498168e-09,1.1283873391221277e-08,8.674500406312268e-09,8.908280751457006e-09,309 +dtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,structure/classes-warm/consumed,2.5334104090392643e-06,3.813119942282984e-09,2.531153306246543e-06,2.550700233057243e-06,2.5325518381054125e-06,2.5362050037268314e-06,192 +dtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,structure/irreducible-cold,6.66151014105211e-05,2.5025493903525444e-07,6.633299121858727e-05,6.681081173486416e-05,6.648122507613152e-05,6.670834633181445e-05,100 +dtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,structure/irreducible-warm,9.750844506003165e-09,2.4748665787675057e-10,9.528674919421095e-09,1.2088954474070929e-08,9.707623204746482e-09,9.853544851564594e-09,307 +dtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,construction/public-consumed,0.028675839527268716,0.00011662030657236082,0.02854611328196673,0.028761888875427154,0.028559254232580617,0.028757564806356745,18 +dtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,evolution/k-10,0.000298467477319522,3.147281255910274e-07,0.0002977997792289862,0.00029867416888030684,0.00029824062512489035,0.00029856542971629096,95 +dtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,evolution/k-100,0.0029485229825710006,2.112600449546932e-06,0.002946729986095746,0.002951393803581299,0.0029474054270272215,0.0029494138141217263,50 +dtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,evolution/one-step,3.295235563870286e-05,3.4488563168650574e-08,3.292649362043812e-05,3.3051492941224575e-05,3.294338680772871e-05,3.296133470908991e-05,140 +dtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,hitting-probability/cold-all-states,0.011595827431717356,3.1314740516501585e-05,0.01156998946632181,0.011643364623523667,0.011566820798907428,0.01162995849881554,15 +dtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,hitting-probability/warm-lookup,2.377703003141592e-08,2.1702083032388e-10,2.35796600120267e-08,2.7338090211147184e-08,2.3673264928647524e-08,2.3916132371183297e-08,288 +dtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,hitting-time/cold-all-states,0.011628884460261554,3.1848185292652e-05,0.011602947495443265,0.012627596290379491,0.011603758063886613,0.012595242582271264,14 +dtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,hitting-time/warm-lookup,2.4059160805623686e-08,2.1806284115835085e-10,2.3868200520845737e-08,2.7261400742852044e-08,2.397339836016059e-08,2.422782319044707e-08,288 +dtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,power/10,0.006712751486312689,0.00010528206973334101,0.006577293118406085,0.006773345466961594,0.006626777208415055,0.006748894438581039,36 +dtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,power/100,0.011049674999473307,8.247331929548372e-05,0.010967201680177823,0.011118439778025882,0.010984963562805206,0.0110986233848962,29 +dtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,power/2,0.004161241816590694,7.588969325444516e-05,0.004092501612608935,0.004236578254334178,0.004117791666526739,0.004203646428400784,44 +dtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,race/forward-committor,0.010906051001964241,5.208450440679496e-05,0.01083707191394821,0.010937730589960535,0.010843123400901766,0.010932395751297008,15 +dtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,return/mean-recurrence,0.05173508829975617,1.1224274965658532e-05,0.051729998037574526,0.051752231939644844,0.051727296467045866,0.05175666700233705,10 +dtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,simulation/10000,0.007178868111724215,0.0001447327386914464,0.007033994796984189,0.007304465246263481,0.007047214519999606,0.007266009362038775,35 +dtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,simulation/100000,0.06270031665848191,0.0004966456401436711,0.06212351521632324,0.0630574830020123,0.062103660211303376,0.06308387583521835,12 +dtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,stationary,0.05140394043181524,6.882819191863371e-06,0.05139746974742189,0.05140981491340427,0.05139590337158653,0.05141630804337183,10 +dtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,structure/classes-cold,0.00014630795116958172,3.360580861681503e-07,0.00014602158443896617,0.0001468500459086647,0.00014622221763905448,0.0001464581993629729,83 +dtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,structure/classes-lifecycle,0.029303236001093563,0.00040921550195586673,0.029242989562590083,0.029866595143435655,0.029242989562590083,0.029866595143435655,17 +dtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,structure/classes-warm/access,8.833564594069165e-09,3.1553863090129e-10,8.524262736882768e-09,1.1609358807618264e-08,8.605400760630926e-09,9.030555633023621e-09,309 +dtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,structure/classes-warm/consumed,2.5327469682195006e-06,4.216991975459247e-09,2.5298076770367444e-06,2.547104569120248e-06,2.531575546527165e-06,2.535203006431253e-06,192 +dtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,structure/irreducible-cold,6.630146725648792e-05,3.861796037252902e-07,6.58893236379394e-05,6.662768276153855e-05,6.60900206474418e-05,6.645721138426912e-05,100 +dtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,structure/irreducible-warm,9.731670458282532e-09,2.455879447759106e-10,9.512860681499633e-09,1.2043735567109163e-08,9.69188073871721e-09,9.80699739417343e-09,307 +dtmc,low-outdegree-n1000-s01729,low-outdegree,1000,1729,construction/public-consumed,0.13168523950177285,0.002184382749874203,0.12956619052783935,0.13285697046203493,0.1292632618569769,0.13403593225120858,8 +dtmc,low-outdegree-n1000-s01729,low-outdegree,1000,1729,evolution/k-10,0.0022973339840222803,8.686244241645075e-07,0.0022963236883177677,0.0022980680828065185,0.0022970000002085445,0.002297891409067564,55 +dtmc,low-outdegree-n1000-s01729,low-outdegree,1000,1729,evolution/k-100,0.022891230577564176,1.0519546443293892e-05,0.022879851687018043,0.022895887987623927,0.02288071103112088,0.022895340765513316,20 +dtmc,low-outdegree-n1000-s01729,low-outdegree,1000,1729,evolution/one-step,0.00023779408482888748,3.6908513720846346e-07,0.00023727761958870568,0.00023808415569161778,0.00023764747196907868,0.00023787876388168015,99 +dtmc,low-outdegree-n1000-s01729,low-outdegree,1000,1729,simulation/10000,0.010201197222599552,6.764255591764148e-06,0.01019676596098136,0.010429581873419616,0.010197425847114312,0.010216564829978136,30 +dtmc,low-outdegree-n1000-s01729,low-outdegree,1000,1729,simulation/100000,0.06589447727310471,0.0016411442775279284,0.06403603450016818,0.06614587669385705,0.06400699399819132,0.06623173949810734,11 +dtmc,low-outdegree-n1000-s01729,low-outdegree,1000,1729,structure/classes-cold,0.00031838933879225237,1.0229295699189147e-06,0.0003175915513326933,0.00031971247022389557,0.0003179480784361342,0.00031888213619360667,68 +dtmc,low-outdegree-n1000-s01729,low-outdegree,1000,1729,structure/classes-lifecycle,0.13263727266712522,0.002270056500735043,0.13112539990743244,0.13483720208362987,0.12764083400543313,0.13504758333632103,8 +dtmc,low-outdegree-n1000-s01729,low-outdegree,1000,1729,structure/classes-warm/access,9.403511404990153e-09,3.6870959448545645e-10,9.107411313726682e-09,1.2107982642161226e-08,9.320420742750825e-09,9.558563915379966e-09,307 +dtmc,low-outdegree-n1000-s01729,low-outdegree,1000,1729,structure/classes-warm/consumed,5.11686689578257e-06,1.0189168701818479e-08,5.109850389299304e-06,5.137558872043685e-06,5.1142647921429864e-06,5.1231884002766534e-06,178 +dtmc,low-outdegree-n1000-s01729,low-outdegree,1000,1729,structure/irreducible-cold,0.00014108528974996742,5.461255840420715e-07,0.00014057859083946907,0.00014164523531118525,0.00014096457120363733,0.00014127901135608275,84 +dtmc,low-outdegree-n1000-s01729,low-outdegree,1000,1729,structure/irreducible-warm,9.615686508446235e-09,1.0282284305126755e-10,9.529046813913926e-09,1.1987061830815841e-08,9.573649291158752e-09,9.710732998842243e-09,307 +dtmc,low-outdegree-n1000-s02718,low-outdegree,1000,2718,construction/public-consumed,0.13194125350006897,0.0024466963929756086,0.13015618574185542,0.13440599567547906,0.12948027371437223,0.1345029832009459,8 +dtmc,low-outdegree-n1000-s02718,low-outdegree,1000,2718,evolution/k-10,0.0022391725714052363,1.5058718937717604e-06,0.0022379030537310416,0.0022411411476491927,0.0022387333010556176,0.002239787982276072,55 +dtmc,low-outdegree-n1000-s02718,low-outdegree,1000,2718,evolution/k-100,0.022302815958168,1.64512227153555e-05,0.02229013446187656,0.022319499751392868,0.022296089496714036,0.022317013750580372,20 +dtmc,low-outdegree-n1000-s02718,low-outdegree,1000,2718,evolution/one-step,0.00023321306774434493,3.4918658610644856e-07,0.0002328529511151877,0.00023354923290528232,0.00023310780959455148,0.0002333235298625796,100 +dtmc,low-outdegree-n1000-s02718,low-outdegree,1000,2718,simulation/10000,0.010126871095659832,2.7146093877187735e-05,0.01011095515143377,0.01052337500732392,0.010116763917418817,0.010224651299358812,29 +dtmc,low-outdegree-n1000-s02718,low-outdegree,1000,2718,simulation/100000,0.06596653662381868,0.002301461821116388,0.06550199231033647,0.06895174653982394,0.0654683638184162,0.06905022232967895,11 +dtmc,low-outdegree-n1000-s02718,low-outdegree,1000,2718,structure/classes-cold,0.00032331467131172317,1.5361967798759838e-06,0.00032192855853483906,0.0003255914176566716,0.0003227807844624571,0.00032415616684981313,67 +dtmc,low-outdegree-n1000-s02718,low-outdegree,1000,2718,structure/classes-lifecycle,0.13291758337497112,0.0016036833874750328,0.13085548957555407,0.13388437285029794,0.130457833428019,0.1341954083996825,8 +dtmc,low-outdegree-n1000-s02718,low-outdegree,1000,2718,structure/classes-warm/access,8.610683043456754e-09,9.778039601511837e-11,8.527136573233896e-09,1.0943040251731873e-08,8.574741803393385e-09,8.691422482301763e-09,309 +dtmc,low-outdegree-n1000-s02718,low-outdegree,1000,2718,structure/classes-warm/consumed,5.099983256628497e-06,4.756171049540712e-09,5.096643908831888e-06,5.113338402293438e-06,5.0989635573286145e-06,5.101156614577424e-06,178 +dtmc,low-outdegree-n1000-s02718,low-outdegree,1000,2718,structure/irreducible-cold,0.00014181407327735053,4.528117290845447e-07,0.00014138098594513877,0.00014226575142821103,0.00014160237811462886,0.00014191237477709318,84 +dtmc,low-outdegree-n1000-s02718,low-outdegree,1000,2718,structure/irreducible-warm,9.652845331905235e-09,1.3057152720061059e-10,9.533597505073466e-09,1.2664643522118831e-08,9.583389272454099e-09,9.724859719161031e-09,307 +dtmc,low-outdegree-n1000-s31415,low-outdegree,1000,31415,construction/public-consumed,0.1320521422494494,0.001991026088424927,0.1303083914556607,0.1335750955419826,0.12956656557175197,0.13408737448644387,8 +dtmc,low-outdegree-n1000-s31415,low-outdegree,1000,31415,evolution/k-10,0.0019434005496805184,2.343141575154189e-06,0.0019412484383078013,0.0019458269309962591,0.0019425461422707803,0.0019447248147367242,58 +dtmc,low-outdegree-n1000-s31415,low-outdegree,1000,31415,evolution/k-100,0.01939552499970887,6.404575105989352e-05,0.019385108350252266,0.020320319466797323,0.019389481443795376,0.020039416800136677,21 +dtmc,low-outdegree-n1000-s31415,low-outdegree,1000,31415,evolution/one-step,0.00020130813132518118,2.6944384483122957e-07,0.00020099218870717084,0.00020154932188796296,0.000201199851828817,0.00020138614505832179,103 +dtmc,low-outdegree-n1000-s31415,low-outdegree,1000,31415,simulation/10000,0.010023519258039397,3.508086270911145e-05,0.009995635965027852,0.010462250258569838,0.010004508551979338,0.010049680560737753,30 +dtmc,low-outdegree-n1000-s31415,low-outdegree,1000,31415,simulation/100000,0.06545975372666196,0.001512801606485023,0.06368459367929193,0.06587130391643667,0.06362931249896064,0.06597738550044596,11 +dtmc,low-outdegree-n1000-s31415,low-outdegree,1000,31415,structure/classes-cold,0.00031052576042001057,1.1052094383298217e-06,0.00030951199356604774,0.0003117844960542514,0.0003102945663330674,0.0003109152269371407,68 +dtmc,low-outdegree-n1000-s31415,low-outdegree,1000,31415,structure/classes-lifecycle,0.13178997662544134,0.002346511915467475,0.13102990551825705,0.13483454171800985,0.13014130957058764,0.13483516666747164,8 +dtmc,low-outdegree-n1000-s31415,low-outdegree,1000,31415,structure/classes-warm/access,8.625939933781118e-09,1.4247603711730477e-10,8.495905493699767e-09,1.0928965448478206e-08,8.568096141069031e-09,8.69928288235316e-09,309 +dtmc,low-outdegree-n1000-s31415,low-outdegree,1000,31415,structure/classes-warm/consumed,5.102291585509262e-06,6.771508579606929e-09,5.097655783801033e-06,5.114974143351486e-06,5.100588667067266e-06,5.103596820924787e-06,178 +dtmc,low-outdegree-n1000-s31415,low-outdegree,1000,31415,structure/irreducible-cold,0.00013947683684321411,6.932451856303046e-07,0.0001386553695051496,0.00014008118204393756,0.0001391971735926384,0.00013969274212805822,84 +dtmc,low-outdegree-n1000-s31415,low-outdegree,1000,31415,structure/irreducible-warm,9.724174871768403e-09,2.2825426596939466e-10,9.517348787009572e-09,1.2239530108834651e-08,9.696288347762268e-09,9.826379533101872e-09,307 +dtmc,periodic-n0010-s01729,periodic,10,1729,construction/public-consumed,6.367365546797328e-06,1.2246137139769366e-08,6.3623396165633554e-06,6.420138729649976e-06,6.366336292945486e-06,6.369828009064211e-06,173 +dtmc,periodic-n0010-s01729,periodic,10,1729,evolution/k-10,1.6465673570667124e-06,6.4933441202933505e-09,1.6426744856352589e-06,1.6764944335550406e-06,1.645043591366474e-06,1.6491158413138081e-06,201 +dtmc,periodic-n0010-s01729,periodic,10,1729,evolution/k-100,3.049571125979977e-06,8.114751388571508e-09,3.042272213796874e-06,3.058009089038238e-06,3.048228956599638e-06,3.0513931392535952e-06,188 +dtmc,periodic-n0010-s01729,periodic,10,1729,evolution/one-step,2.4452307086384495e-07,9.433987583378838e-09,2.350740044962893e-07,2.516876922039817e-07,2.4344934043022277e-07,2.4523784405674735e-07,241 +dtmc,periodic-n0010-s01729,periodic,10,1729,finite-time/n-step/k-10,3.1907376912507305e-06,9.136903653113836e-09,3.1823594848295517e-06,3.201606813867256e-06,3.1883144471922477e-06,3.193598067851473e-06,162 +dtmc,periodic-n0010-s01729,periodic,10,1729,finite-time/n-step/k-100,1.9599973333307205e-05,2.3957159494715762e-08,1.958484115553453e-05,1.9630870187060315e-05,1.95961591643375e-05,1.960912432925972e-05,139 +dtmc,periodic-n0010-s01729,periodic,10,1729,finite-time/observation/k-10,2.7848560829692428e-05,3.652963849900038e-08,2.7819527797388916e-05,2.7888415456740213e-05,2.7840055607579333e-05,2.785803214646876e-05,134 +dtmc,periodic-n0010-s01729,periodic,10,1729,finite-time/observation/k-100,0.0002531895379766364,2.0480605284763738e-07,0.0002529904573188665,0.00025342368810289266,0.0002531360518484386,0.0002532698043627241,97 +dtmc,periodic-n0010-s01729,periodic,10,1729,finite-time/step,7.507643466405202e-07,4.2698936003168204e-09,7.465399845004878e-07,7.550672755559966e-07,7.494772715257866e-07,7.515191100537777e-07,192 +dtmc,periodic-n0010-s01729,periodic,10,1729,hitting-probability/cold-all-states,1.5932178953279898e-05,1.0213228257247256e-07,1.5867744995073338e-05,1.616978655040572e-05,1.5909953052057334e-05,1.596903585029387e-05,139 +dtmc,periodic-n0010-s01729,periodic,10,1729,hitting-probability/warm-lookup,2.3751432975212727e-08,1.3052149086534455e-10,2.363976972061915e-08,2.6724312472372102e-08,2.3721167751790834e-08,2.3874425946109487e-08,288 +dtmc,periodic-n0010-s01729,periodic,10,1729,hitting-time/cold-all-states,1.4311654926740206e-05,5.514206243988625e-08,1.4270375226720257e-05,1.4405066901547668e-05,1.4297928124082345e-05,1.4330150395362203e-05,140 +dtmc,periodic-n0010-s01729,periodic,10,1729,hitting-time/warm-lookup,2.40674500889741e-08,1.8582831610992047e-10,2.3908122195374612e-08,2.7346888475538598e-08,2.4002145117160994e-08,2.425739074245344e-08,288 +dtmc,periodic-n0010-s01729,periodic,10,1729,hitting/bounded/at-most/k-10,2.5859530149040877e-06,1.8165869363314725e-08,2.572366563407214e-06,2.6249703574223584e-06,2.5805107321098653e-06,2.591883013438847e-06,165 +dtmc,periodic-n0010-s01729,periodic,10,1729,hitting/bounded/at-most/k-100,2.5810217408151058e-06,1.3598190787075682e-08,2.564066406756812e-06,2.5923989442612516e-06,2.57317311957016e-06,2.5864574126899242e-06,166 +dtmc,periodic-n0010-s01729,periodic,10,1729,hitting/bounded/exact/k-10,2.4449065812889523e-06,8.762670835200457e-09,2.438213915573066e-06,2.481129554961558e-06,2.4424412995845142e-06,2.4476294410559013e-06,167 +dtmc,periodic-n0010-s01729,periodic,10,1729,hitting/bounded/exact/k-100,2.4318891375462404e-06,1.2304768602230905e-08,2.4181600519457174e-06,2.442450558060148e-06,2.429578811503374e-06,2.4336819958031e-06,167 +dtmc,periodic-n0010-s01729,periodic,10,1729,hitting/bounded/greater-than/k-10,2.468846460297993e-06,8.437192743185457e-09,2.461817486397222e-06,2.4779354229463196e-06,2.4667302858543353e-06,2.470600015925196e-06,167 +dtmc,periodic-n0010-s01729,periodic,10,1729,hitting/bounded/greater-than/k-100,2.4482036536160044e-06,8.407885784589584e-09,2.4410328907695283e-06,2.4594802121557365e-06,2.446345019656652e-06,2.4500550291359825e-06,166 +dtmc,periodic-n0010-s01729,periodic,10,1729,power/10,4.3996366333555095e-06,2.71320583717985e-08,4.3752057964037005e-06,4.44736858633788e-06,4.390398448711072e-06,4.408928525291991e-06,181 +dtmc,periodic-n0010-s01729,periodic,10,1729,power/100,5.680217138932868e-06,2.0942341689070034e-08,5.665485952738206e-06,5.7959555752128e-06,5.673383429390472e-06,5.693843256187609e-06,176 +dtmc,periodic-n0010-s01729,periodic,10,1729,power/2,3.3177571125311135e-06,1.1381536622304465e-08,3.3104681137067043e-06,3.376787409503409e-06,3.3161344645187026e-06,3.3210361648508043e-06,185 +dtmc,periodic-n0010-s01729,periodic,10,1729,return/bounded/k-10,3.4489845007088103e-06,1.1500066778223423e-08,3.4372205569653477e-06,3.459556349856435e-06,3.446304290510426e-06,3.451747591028071e-06,160 +dtmc,periodic-n0010-s01729,periodic,10,1729,return/bounded/k-100,3.4428791326716596e-06,9.5865306632767e-09,3.4315031360714773e-06,3.451271464533524e-06,3.438425323603539e-06,3.4455442801117897e-06,160 +dtmc,periodic-n0010-s01729,periodic,10,1729,stationary,5.811565793827519e-06,2.878242953129564e-08,5.79233966694076e-06,5.935261638283178e-06,5.805832522644384e-06,5.818982841446996e-06,149 +dtmc,periodic-n0010-s01729,periodic,10,1729,structure/classes-cold,2.469384144075157e-06,7.12744664839243e-09,2.4635022815753686e-06,2.4784605872681363e-06,2.468365783445865e-06,2.4711820731034217e-06,167 +dtmc,periodic-n0010-s01729,periodic,10,1729,structure/classes-lifecycle,7.742087858063884e-06,1.927578755653486e-08,7.723088553272342e-06,7.761363645620419e-06,7.737772111321824e-06,7.747364453466452e-06,169 +dtmc,periodic-n0010-s01729,periodic,10,1729,structure/classes-warm/access,8.652331832493023e-09,1.3415104848622217e-10,8.529525115981216e-09,1.0856089850069572e-08,8.584521194892095e-09,8.706075179613372e-09,309 +dtmc,periodic-n0010-s01729,periodic,10,1729,structure/classes-warm/consumed,4.0771054898655674e-08,2.3184833389681725e-10,4.0605906785155334e-08,4.4313541581948936e-08,4.069348471397453e-08,4.096563201024311e-08,277 +dtmc,periodic-n0010-s01729,periodic,10,1729,structure/cyclic-classes-cold,3.95441020373255e-06,2.1334073770869384e-08,3.938035948948174e-06,3.980295497704377e-06,3.948449118054433e-06,3.965621144467858e-06,158 +dtmc,periodic-n0010-s01729,periodic,10,1729,structure/cyclic-classes-warm,9.128191427757534e-07,1.8764778238852768e-09,9.118600640939756e-07,9.288325452724019e-07,9.125260976139941e-07,9.133573101810459e-07,213 +dtmc,periodic-n0010-s01729,periodic,10,1729,structure/irreducible-cold,1.5866610259969823e-06,5.659922133533256e-09,1.5819142110793024e-06,1.5964273419711623e-06,1.584352211610026e-06,1.5885639789231707e-06,176 +dtmc,periodic-n0010-s01729,periodic,10,1729,structure/irreducible-warm,9.654651522439217e-09,1.3623803799560023e-10,9.528434382102935e-09,1.1950784060150165e-08,9.574673013617426e-09,9.747435799045508e-09,307 +dtmc,periodic-n0010-s01729,periodic,10,1729,structure/period-cold,2.650540538466415e-06,1.540643662762552e-08,2.6340225228251395e-06,2.6630593014451023e-06,2.646315387193687e-06,2.655180816707963e-06,166 +dtmc,periodic-n0010-s01729,periodic,10,1729,structure/period-warm,1.1870041042846508e-08,1.9542520572952373e-10,1.170768675918419e-08,1.4680513039326024e-08,1.1803672668809945e-08,1.2062305314557367e-08,302 +dtmc,periodic-n0010-s01729,periodic,10,1729,visits/bounded-expectation/k-10,2.875831045281128e-06,3.594273490422478e-08,2.834341615519423e-06,2.899860791042224e-06,2.870653279077757e-06,2.883122003865692e-06,164 +dtmc,periodic-n0010-s01729,periodic,10,1729,visits/bounded-expectation/k-100,1.7482096634278006e-05,2.2963000016654433e-08,1.746139909265808e-05,1.7507479561892388e-05,1.7475851043074606e-05,1.748604879069787e-05,140 +dtmc,periodic-n0010-s02718,periodic,10,2718,construction/public-consumed,6.364583003290687e-06,1.095695846179592e-08,6.3570468018379885e-06,6.390115054555039e-06,6.3626805399887025e-06,6.367929723345516e-06,173 +dtmc,periodic-n0010-s02718,periodic,10,2718,evolution/k-10,1.6475807002935564e-06,5.658916183080293e-09,1.6428048253993222e-06,1.6907895833515284e-06,1.645268005797861e-06,1.6493844575794896e-06,201 +dtmc,periodic-n0010-s02718,periodic,10,2718,evolution/k-100,3.064845554833946e-06,8.402938459253494e-09,3.0564999928772994e-06,3.0730935500321855e-06,3.062936577664037e-06,3.0665002090509164e-06,188 +dtmc,periodic-n0010-s02718,periodic,10,2718,evolution/one-step,2.447759736325211e-07,9.611847114022435e-09,2.3516412651849868e-07,2.541118623125122e-07,2.4391475579896924e-07,2.453789672712742e-07,241 +dtmc,periodic-n0010-s02718,periodic,10,2718,finite-time/n-step/k-10,3.1827791839340823e-06,1.799355555600968e-08,3.164202829803743e-06,3.198791154558484e-06,3.1761638785830554e-06,3.18751645628018e-06,162 +dtmc,periodic-n0010-s02718,periodic,10,2718,finite-time/n-step/k-100,1.954932712788622e-05,2.8602961359854403e-08,1.9527352204641582e-05,1.959639763973317e-05,1.953786491453279e-05,1.9560908089931073e-05,139 +dtmc,periodic-n0010-s02718,periodic,10,2718,finite-time/observation/k-10,2.7774517938998448e-05,4.880552781783117e-08,2.773367859330358e-05,2.7834686993035418e-05,2.7766059324445233e-05,2.77897844713733e-05,134 +dtmc,periodic-n0010-s02718,periodic,10,2718,finite-time/observation/k-100,0.0002667037125710132,2.6583606140912147e-06,0.0002528875625255555,0.00026812747025608337,0.00026453239034809585,0.0002673122031990425,97 +dtmc,periodic-n0010-s02718,periodic,10,2718,finite-time/step,7.73396838284117e-07,7.2646990392944664e-09,7.670410273694681e-07,7.830671140628859e-07,7.716913526756116e-07,7.758766876340192e-07,191 +dtmc,periodic-n0010-s02718,periodic,10,2718,hitting-probability/cold-all-states,1.5853525409885845e-05,9.123903528479737e-08,1.578613552212596e-05,1.6016608741177878e-05,1.5815965265833904e-05,1.5884986707675908e-05,139 +dtmc,periodic-n0010-s02718,periodic,10,2718,hitting-probability/warm-lookup,2.382788804883426e-08,2.0532502170072956e-10,2.3636998683090294e-08,2.6892570570270712e-08,2.3748519413810335e-08,2.3948714376726115e-08,288 +dtmc,periodic-n0010-s02718,periodic,10,2718,hitting-time/cold-all-states,1.4203864247239833e-05,4.1887316133345556e-08,1.4164955489070518e-05,1.4256068523034227e-05,1.4196607977416837e-05,1.4216816402028518e-05,140 +dtmc,periodic-n0010-s02718,periodic,10,2718,hitting-time/warm-lookup,2.4377981434454546e-08,4.848223543992471e-10,2.390807469456514e-08,2.818937050665726e-08,2.4078704012067518e-08,2.4511093903130328e-08,288 +dtmc,periodic-n0010-s02718,periodic,10,2718,hitting/bounded/at-most/k-10,2.5517883903718092e-06,1.287719101579745e-08,2.542317416116056e-06,2.718170968970905e-06,2.5490264423279073e-06,2.553446193573318e-06,166 +dtmc,periodic-n0010-s02718,periodic,10,2718,hitting/bounded/at-most/k-100,2.5212736040675342e-06,1.1479561311374066e-08,2.5087047811675987e-06,2.531408041008708e-06,2.517799907318298e-06,2.5242813976639183e-06,167 +dtmc,periodic-n0010-s02718,periodic,10,2718,hitting/bounded/exact/k-10,2.4445578295756255e-06,9.251009899813384e-09,2.437490191972791e-06,2.459265883940302e-06,2.4420454357029266e-06,2.4478824140718176e-06,167 +dtmc,periodic-n0010-s02718,periodic,10,2718,hitting/bounded/exact/k-100,2.4404172537146415e-06,7.694970971384704e-09,2.434666121988169e-06,2.4518442937933916e-06,2.438491228820076e-06,2.4420067202299833e-06,167 +dtmc,periodic-n0010-s02718,periodic,10,2718,hitting/bounded/greater-than/k-10,2.442053000260817e-06,9.941834635109993e-09,2.4333997691214524e-06,2.4528779822071066e-06,2.438891270733517e-06,2.4454627719069693e-06,167 +dtmc,periodic-n0010-s02718,periodic,10,2718,hitting/bounded/greater-than/k-100,2.4289456836371305e-06,1.2242053803453782e-08,2.416959737917261e-06,2.4411491381337566e-06,2.426511944932649e-06,2.431425870300326e-06,168 +dtmc,periodic-n0010-s02718,periodic,10,2718,power/10,4.413112736644917e-06,5.353512724795835e-09,4.40896579160007e-06,4.427100066095591e-06,4.411937967613456e-06,4.414521555853513e-06,181 +dtmc,periodic-n0010-s02718,periodic,10,2718,power/100,5.72117521128051e-06,8.722139343339265e-09,5.713564269332451e-06,5.731591398140614e-06,5.719700699892601e-06,5.72335928394021e-06,175 +dtmc,periodic-n0010-s02718,periodic,10,2718,power/2,3.3678361204124647e-06,1.1382107157885254e-08,3.3596392185623754e-06,3.435593804169912e-06,3.3644917297379793e-06,3.374801253225778e-06,186 +dtmc,periodic-n0010-s02718,periodic,10,2718,return/bounded/k-10,3.4256079068469046e-06,1.9476396404911305e-08,3.409774476432637e-06,3.4530322799193006e-06,3.4183379193303576e-06,3.432719192157189e-06,161 +dtmc,periodic-n0010-s02718,periodic,10,2718,return/bounded/k-100,3.450532762150076e-06,1.4093950505476941e-08,3.440566934881121e-06,3.468908525156296e-06,3.446754502686091e-06,3.4529384720372036e-06,160 +dtmc,periodic-n0010-s02718,periodic,10,2718,stationary,5.926592469525834e-06,4.461112997919507e-08,5.8849053575573935e-06,5.978242269419651e-06,5.9176228666095914e-06,5.942384692995498e-06,149 +dtmc,periodic-n0010-s02718,periodic,10,2718,structure/classes-cold,2.5043220101100096e-06,1.2007718675840276e-08,2.4962306768147714e-06,2.5244768212793305e-06,2.5021509408657806e-06,2.510387101985844e-06,167 +dtmc,periodic-n0010-s02718,periodic,10,2718,structure/classes-lifecycle,7.890625056461431e-06,1.1566553274304305e-07,7.75423888548259e-06,7.991802924538426e-06,7.876136805862188e-06,7.908319821581244e-06,169 +dtmc,periodic-n0010-s02718,periodic,10,2718,structure/classes-warm/access,8.601027944892883e-09,8.312356191825351e-11,8.528984816527108e-09,1.0775860489999084e-08,8.577953673081815e-09,8.675377947712366e-09,309 +dtmc,periodic-n0010-s02718,periodic,10,2718,structure/classes-warm/consumed,4.082668183379369e-08,2.627072016759934e-10,4.061305791282688e-08,4.3989577775217517e-08,4.0743671335125616e-08,4.1007030951176946e-08,277 +dtmc,periodic-n0010-s02718,periodic,10,2718,structure/cyclic-classes-cold,3.99190253048272e-06,2.6447736956677784e-08,3.975081537923143e-06,4.028533779395123e-06,3.98763339254761e-06,3.997459596288081e-06,157 +dtmc,periodic-n0010-s02718,periodic,10,2718,structure/cyclic-classes-warm,9.145260217514912e-07,3.5921075613682413e-09,9.119751593657364e-07,9.324654570099098e-07,9.131640375701909e-07,9.166891489881103e-07,212 +dtmc,periodic-n0010-s02718,periodic,10,2718,structure/irreducible-cold,1.654559048851555e-06,1.0502311518017147e-08,1.643642505375174e-06,1.6641701626617255e-06,1.6521846603370375e-06,1.6576705887969295e-06,175 +dtmc,periodic-n0010-s02718,periodic,10,2718,structure/irreducible-warm,9.60138481766924e-09,8.912237824920735e-11,9.527040375748646e-09,1.1799930616271222e-08,9.554659665767791e-09,9.695576318586e-09,307 +dtmc,periodic-n0010-s02718,periodic,10,2718,structure/period-cold,2.7079875854330387e-06,1.4056934824407271e-08,2.6958383212680233e-06,2.7233568580766904e-06,2.702877259548671e-06,2.710577590685142e-06,165 +dtmc,periodic-n0010-s02718,periodic,10,2718,structure/period-warm,1.1908505525771094e-08,2.381884955837877e-10,1.1683089907001068e-08,1.4456556574480551e-08,1.180208357483432e-08,1.200638962035453e-08,302 +dtmc,periodic-n0010-s02718,periodic,10,2718,visits/bounded-expectation/k-10,2.8074373403796926e-06,1.0416918574400676e-08,2.7990380534811936e-06,2.8215623128094843e-06,2.805118426795916e-06,2.8105109913918e-06,165 +dtmc,periodic-n0010-s02718,periodic,10,2718,visits/bounded-expectation/k-100,1.7409093118569952e-05,2.9497119182721654e-08,1.7381916479759838e-05,1.7443248533886233e-05,1.740103891333978e-05,1.7418695945233776e-05,140 +dtmc,periodic-n0010-s31415,periodic,10,31415,construction/public-consumed,6.376303515155866e-06,1.7220040645620666e-08,6.3621222701885065e-06,6.439285685441324e-06,6.367444143656264e-06,6.382628420337302e-06,173 +dtmc,periodic-n0010-s31415,periodic,10,31415,evolution/k-10,1.650576879901987e-06,5.58082618161287e-09,1.6465248513222142e-06,1.6770848430626626e-06,1.6482502062820139e-06,1.6532523059451393e-06,201 +dtmc,periodic-n0010-s31415,periodic,10,31415,evolution/k-100,3.0660734116393705e-06,8.102480456422085e-09,3.0611869985360347e-06,3.083579825837851e-06,3.0642894145212043e-06,3.0682328868901945e-06,188 +dtmc,periodic-n0010-s31415,periodic,10,31415,evolution/one-step,2.452474198089582e-07,9.449181164285179e-09,2.3581785316345687e-07,2.549432539717131e-07,2.440029150882537e-07,2.4675261160664294e-07,241 +dtmc,periodic-n0010-s31415,periodic,10,31415,finite-time/n-step/k-10,3.1768938215188402e-06,1.1899675569065566e-08,3.164872735627289e-06,3.1884956570626905e-06,3.17238902968815e-06,3.1803660001702955e-06,162 +dtmc,periodic-n0010-s31415,periodic,10,31415,finite-time/n-step/k-100,1.9554797568455005e-05,3.449690913399125e-08,1.9531557582388044e-05,1.963498765346942e-05,1.9545147958350307e-05,1.9565023943217133e-05,139 +dtmc,periodic-n0010-s31415,periodic,10,31415,finite-time/observation/k-10,2.782053504023702e-05,7.723110517735975e-08,2.7759842745769894e-05,2.7969941955825334e-05,2.779353936679706e-05,2.7841742294073945e-05,134 +dtmc,periodic-n0010-s31415,periodic,10,31415,finite-time/observation/k-100,0.000252509087263404,3.223095033707689e-07,0.0002522216807458622,0.00025287916553982844,0.00025242720658764174,0.00025267363012330057,97 +dtmc,periodic-n0010-s31415,periodic,10,31415,finite-time/step,7.839185663645989e-07,2.121303991176318e-08,7.60176406090837e-07,8.009743777723985e-07,7.76195311223039e-07,7.893621740448806e-07,191 +dtmc,periodic-n0010-s31415,periodic,10,31415,hitting-probability/cold-all-states,1.628140471119989e-05,2.583781508510357e-07,1.607430292516137e-05,1.6701932798808493e-05,1.617397250864061e-05,1.6438201850245673e-05,132 +dtmc,periodic-n0010-s31415,periodic,10,31415,hitting-probability/warm-lookup,2.956220736518002e-08,4.957866030220737e-09,2.543009470753294e-08,4.808562950704966e-08,2.8120264120888514e-08,3.1826453373974395e-08,279 +dtmc,periodic-n0010-s31415,periodic,10,31415,hitting-time/cold-all-states,1.5773284760616667e-05,9.046330186722256e-07,1.5137412893284795e-05,1.8123093923350098e-05,1.542559961957642e-05,1.607364020818015e-05,138 +dtmc,periodic-n0010-s31415,periodic,10,31415,hitting-time/warm-lookup,2.4561607489660743e-08,5.876123847536126e-10,2.414153153727229e-08,2.8222212262399237e-08,2.4419770551543898e-08,2.4814878969862196e-08,288 +dtmc,periodic-n0010-s31415,periodic,10,31415,hitting/bounded/at-most/k-10,2.55475886346722e-06,1.0806079742243212e-08,2.5451060986030852e-06,2.566951996714283e-06,2.5527750274039154e-06,2.5566698053012533e-06,166 +dtmc,periodic-n0010-s31415,periodic,10,31415,hitting/bounded/at-most/k-100,2.5676796780398438e-06,1.697795985248148e-08,2.5573610493617723e-06,2.721133209969647e-06,2.5632713279143386e-06,2.5744753265652396e-06,166 +dtmc,periodic-n0010-s31415,periodic,10,31415,hitting/bounded/exact/k-10,2.4608499943214428e-06,1.0802508493485799e-08,2.452444738970035e-06,2.472927370857767e-06,2.4583420396278966e-06,2.465707332114963e-06,167 +dtmc,periodic-n0010-s31415,periodic,10,31415,hitting/bounded/exact/k-100,2.467152394363474e-06,9.859514471131578e-09,2.4580917451364124e-06,2.4801511432042077e-06,2.464785867334272e-06,2.468639991261296e-06,167 +dtmc,periodic-n0010-s31415,periodic,10,31415,hitting/bounded/greater-than/k-10,2.4217904022554473e-06,1.3065188057646586e-08,2.4085392696452713e-06,2.4338295150886178e-06,2.418062628612792e-06,2.423577172187518e-06,168 +dtmc,periodic-n0010-s31415,periodic,10,31415,hitting/bounded/greater-than/k-100,2.443215243567308e-06,2.3011401495642804e-08,2.426206070268503e-06,2.5760337196611562e-06,2.436326202017386e-06,2.454023917234203e-06,167 +dtmc,periodic-n0010-s31415,periodic,10,31415,power/10,4.388441439089438e-06,1.1532251517868331e-08,4.380820749001051e-06,4.449073997050248e-06,4.386087742526496e-06,4.3974735155260485e-06,181 +dtmc,periodic-n0010-s31415,periodic,10,31415,power/100,5.6866428579499295e-06,8.976783944532364e-09,5.6813536161800155e-06,5.712411970384321e-06,5.685350717747699e-06,5.6892959918412895e-06,176 +dtmc,periodic-n0010-s31415,periodic,10,31415,power/2,3.3222153433598577e-06,6.002604816879577e-09,3.3184518936469692e-06,3.345714276961348e-06,3.3212044886797937e-06,3.3243243303488777e-06,187 +dtmc,periodic-n0010-s31415,periodic,10,31415,return/bounded/k-10,3.4393854188218302e-06,1.5741174746602558e-08,3.426975042795142e-06,3.4630680099313706e-06,3.4339926036736496e-06,3.4437861027795174e-06,160 +dtmc,periodic-n0010-s31415,periodic,10,31415,return/bounded/k-100,3.4415590963973216e-06,1.5322469529956504e-08,3.4283018543473665e-06,3.4579070910955127e-06,3.4371198539783853e-06,3.4464904502737613e-06,160 +dtmc,periodic-n0010-s31415,periodic,10,31415,stationary,6.0172781487593395e-06,5.470344768464317e-08,5.971401941823277e-06,6.141094115352438e-06,5.990442542287593e-06,6.02502004136756e-06,149 +dtmc,periodic-n0010-s31415,periodic,10,31415,structure/classes-cold,2.5356052159215184e-06,8.171606937822493e-09,2.5272884105675536e-06,2.543398263287129e-06,2.533619380283403e-06,2.5379822699952934e-06,165 +dtmc,periodic-n0010-s31415,periodic,10,31415,structure/classes-lifecycle,7.768286349833137e-06,2.567452420928145e-08,7.747438436266609e-06,7.826922228559852e-06,7.763184207009504e-06,7.773713828982653e-06,169 +dtmc,periodic-n0010-s31415,periodic,10,31415,structure/classes-warm/access,8.658035130096793e-09,1.4672379166570954e-10,8.524044873325528e-09,1.104516664475023e-08,8.591384355695294e-09,8.72503831956645e-09,309 +dtmc,periodic-n0010-s31415,periodic,10,31415,structure/classes-warm/consumed,4.116144628927205e-08,5.808541220594496e-10,4.061619634790337e-08,4.407304983872634e-08,4.096203480669474e-08,4.142916045403442e-08,277 +dtmc,periodic-n0010-s31415,periodic,10,31415,structure/cyclic-classes-cold,4.063719946271967e-06,2.2751996540782206e-08,4.048701070825614e-06,4.288438940420747e-06,4.059997719186958e-06,4.069510658035847e-06,157 +dtmc,periodic-n0010-s31415,periodic,10,31415,structure/cyclic-classes-warm,9.14233630962661e-07,2.2335701734430925e-09,9.125780593527364e-07,9.290877067925115e-07,9.13728189283409e-07,9.148810918589699e-07,213 +dtmc,periodic-n0010-s31415,periodic,10,31415,structure/irreducible-cold,1.6500226463596448e-06,7.509502587476839e-09,1.6436725819357948e-06,1.658992782309228e-06,1.6479889882362788e-06,1.6523294061379558e-06,176 +dtmc,periodic-n0010-s31415,periodic,10,31415,structure/irreducible-warm,9.626626748448486e-09,1.0965595186704525e-10,9.536196434399093e-09,1.2162639316933251e-08,9.577661932068293e-09,9.69257291724698e-09,307 +dtmc,periodic-n0010-s31415,periodic,10,31415,structure/period-cold,2.7030232644701413e-06,1.757765350819159e-08,2.6854456109619497e-06,2.7204523869459667e-06,2.6969659798355265e-06,2.7094350078870416e-06,165 +dtmc,periodic-n0010-s31415,periodic,10,31415,structure/period-warm,1.1892979162610516e-08,2.2854580009276076e-10,1.1678164216465397e-08,1.4292207070327228e-08,1.1840797478745736e-08,1.2010689700303906e-08,302 +dtmc,periodic-n0010-s31415,periodic,10,31415,visits/bounded-expectation/k-10,2.8341881660122603e-06,1.3360138240826693e-08,2.821754073100943e-06,2.8525159677378523e-06,2.830885647449131e-06,2.8354283707191676e-06,164 +dtmc,periodic-n0010-s31415,periodic,10,31415,visits/bounded-expectation/k-100,1.7432020615291848e-05,3.3895206645360735e-08,1.7397531485490993e-05,1.7462056675037445e-05,1.7420125089901656e-05,1.7438212507821407e-05,140 +dtmc,periodic-n0025-s01729,periodic,25,1729,construction/public-consumed,3.722214483650152e-05,1.223484032354235e-07,3.71591795882779e-05,3.798640801153165e-05,3.719444446785015e-05,3.7348453505811364e-05,137 +dtmc,periodic-n0025-s01729,periodic,25,1729,evolution/k-10,2.3282662397198207e-06,5.759098364106301e-09,2.3244620112067954e-06,2.348571813982371e-06,2.327741204161392e-06,2.3293679224765483e-06,194 +dtmc,periodic-n0025-s01729,periodic,25,1729,evolution/k-100,8.680748349756014e-06,4.880580759323716e-08,8.623184899638139e-06,8.716504819956216e-06,8.664294322834739e-06,8.689997577081572e-06,167 +dtmc,periodic-n0025-s01729,periodic,25,1729,evolution/one-step,3.955570779630915e-07,8.104003318206232e-09,3.8745380298131813e-07,4.060039575959715e-07,3.9167943197748563e-07,3.9650661620970424e-07,231 +dtmc,periodic-n0025-s01729,periodic,25,1729,finite-time/n-step/k-10,4.338063965852701e-06,1.2213189480039779e-08,4.326425533030681e-06,4.35171474924082e-06,4.333672859863168e-06,4.342999774962664e-06,156 +dtmc,periodic-n0025-s01729,periodic,25,1729,finite-time/n-step/k-100,2.9569510586993883e-05,2.5637729626980753e-08,2.9546026742092676e-05,2.9596738787281737e-05,2.9565067625106604e-05,2.958196919595773e-05,120 +dtmc,periodic-n0025-s01729,periodic,25,1729,finite-time/observation/k-10,0.00010642237509568026,1.1684556289549613e-07,0.00010628044020747379,0.00010651789334536494,0.00010638286613639051,0.00010645570514230606,107 +dtmc,periodic-n0025-s01729,periodic,25,1729,finite-time/observation/k-100,0.0010102826743402854,1.1222716609522992e-06,0.0010095417319538713,0.0010123052432353856,0.001009846162667279,0.0010108851067453736,69 +dtmc,periodic-n0025-s01729,periodic,25,1729,finite-time/step,8.117123340505128e-07,7.375377094608249e-09,8.048290366181486e-07,8.192587628791112e-07,8.098348316090841e-07,8.131945477963842e-07,190 +dtmc,periodic-n0025-s01729,periodic,25,1729,hitting-probability/cold-all-states,3.8077580187637864e-05,1.540756571476565e-07,3.7899077040480885e-05,3.821272027699185e-05,3.8007343295071505e-05,3.81101870476412e-05,116 +dtmc,periodic-n0025-s01729,periodic,25,1729,hitting-probability/warm-lookup,2.367775722661003e-08,1.0931732163001838e-10,2.3589246373409895e-08,2.7750804278007915e-08,2.363221396706074e-08,2.3785801939582472e-08,288 +dtmc,periodic-n0025-s01729,periodic,25,1729,hitting-time/cold-all-states,3.515608845022202e-05,6.30855146563193e-08,3.510563052259386e-05,3.523794829992479e-05,3.514556352011099e-05,3.517812089712331e-05,117 +dtmc,periodic-n0025-s01729,periodic,25,1729,hitting-time/warm-lookup,2.3941472795331083e-08,1.0816334019040225e-10,2.385418098245641e-08,2.7031177983639743e-08,2.389546537398233e-08,2.407154758830129e-08,288 +dtmc,periodic-n0025-s01729,periodic,25,1729,hitting/bounded/at-most/k-10,5.166759365238249e-06,2.0823305627952048e-07,4.932477337183756e-06,5.267163394146586e-06,5.038647527644734e-06,5.201164943476518e-06,153 +dtmc,periodic-n0025-s01729,periodic,25,1729,hitting/bounded/at-most/k-100,5.586331965224374e-06,1.4079288633108677e-08,5.575227045098032e-06,5.607571174978092e-06,5.583428511662143e-06,5.591538501903414e-06,147 +dtmc,periodic-n0025-s01729,periodic,25,1729,hitting/bounded/exact/k-10,4.8204085599518404e-06,1.3222080081803673e-08,4.809430455755393e-06,4.835918193124349e-06,4.816112600112062e-06,4.8249937340761854e-06,154 +dtmc,periodic-n0025-s01729,periodic,25,1729,hitting/bounded/exact/k-100,5.522773452259488e-06,6.749642293823058e-08,5.48155385992138e-06,6.090272962736877e-06,5.508872011746074e-06,5.621040845211826e-06,150 +dtmc,periodic-n0025-s01729,periodic,25,1729,hitting/bounded/greater-than/k-10,4.794576281024721e-06,1.50585882533143e-08,4.7844599155084595e-06,4.813213736152036e-06,4.790654640169692e-06,4.801480533466849e-06,154 +dtmc,periodic-n0025-s01729,periodic,25,1729,hitting/bounded/greater-than/k-100,5.390832874192191e-06,2.47600837610662e-08,5.371635863894944e-06,5.44212926835694e-06,5.382518333113607e-06,5.406779609831524e-06,151 +dtmc,periodic-n0025-s01729,periodic,25,1729,power/10,1.6554417492970375e-05,4.0351261706829283e-08,1.6502409905458943e-05,1.658357606651197e-05,1.654309875416299e-05,1.6564549924729004e-05,154 +dtmc,periodic-n0025-s01729,periodic,25,1729,power/100,2.0347153765004307e-05,1.320728686042998e-07,2.01673588237456e-05,2.0458447155337388e-05,2.028595713990276e-05,2.0386433523494455e-05,149 +dtmc,periodic-n0025-s01729,periodic,25,1729,power/2,1.335479167998499e-05,3.3677999239751526e-08,1.3330925835115099e-05,1.3558838877523545e-05,1.3346894292944908e-05,1.3362086953448126e-05,158 +dtmc,periodic-n0025-s01729,periodic,25,1729,return/bounded/k-10,4.608829390981955e-06,2.5545617253516746e-08,4.583701363068373e-06,4.64169624021665e-06,4.598623388014525e-06,4.615364309427315e-06,154 +dtmc,periodic-n0025-s01729,periodic,25,1729,return/bounded/k-100,9.27142868655534e-06,1.5505962818816084e-08,9.259402238327238e-06,9.293926086540017e-06,9.267812818678207e-06,9.277220225378406e-06,140 +dtmc,periodic-n0025-s01729,periodic,25,1729,stationary,1.5909715286744314e-05,4.2641056094303655e-08,1.586941216373816e-05,1.5959987649694085e-05,1.589579439110802e-05,1.5927605044471063e-05,129 +dtmc,periodic-n0025-s01729,periodic,25,1729,structure/classes-cold,4.543148073984461e-06,1.4792976655346623e-08,4.529049062356827e-06,4.565388335094387e-06,4.5392140599194025e-06,4.548167529050719e-06,154 +dtmc,periodic-n0025-s01729,periodic,25,1729,structure/classes-lifecycle,4.043651822333535e-05,5.889339566541495e-08,4.037388252325876e-05,4.048749360663351e-05,4.041975308636035e-05,4.0446557956612735e-05,135 +dtmc,periodic-n0025-s01729,periodic,25,1729,structure/classes-warm/access,8.62538657071147e-09,1.0761566733248359e-10,8.538068291829846e-09,1.089654102835847e-08,8.589348149730125e-09,8.727139484079313e-09,309 +dtmc,periodic-n0025-s01729,periodic,25,1729,structure/classes-warm/consumed,1.0612875949243855e-07,3.9474975350683885e-10,1.0589272793635839e-07,1.1081086798898272e-07,1.060217609001845e-07,1.0636654908654614e-07,257 +dtmc,periodic-n0025-s01729,periodic,25,1729,structure/cyclic-classes-cold,7.815382721590057e-06,2.625517387111916e-08,7.794214750410168e-06,7.849038886856614e-06,7.807364536542462e-06,7.824402942206147e-06,144 +dtmc,periodic-n0025-s01729,periodic,25,1729,structure/cyclic-classes-warm,2.2159446650004603e-06,3.8087421840738335e-09,2.2135767482139912e-06,2.2319439736951776e-06,2.21508143022799e-06,2.2180314738092556e-06,195 +dtmc,periodic-n0025-s01729,periodic,25,1729,structure/irreducible-cold,2.5525496730954223e-06,1.0750682432759296e-08,2.540895598681796e-06,2.5621682232565915e-06,2.5485308496424226e-06,2.5552664273304693e-06,166 +dtmc,periodic-n0025-s01729,periodic,25,1729,structure/irreducible-warm,9.659303930670585e-09,1.333337338745672e-10,9.545364766047191e-09,1.2152225733212689e-08,9.599383846217933e-09,9.754854589730586e-09,307 +dtmc,periodic-n0025-s01729,periodic,25,1729,structure/period-cold,4.852325695663177e-06,2.246483279273359e-08,4.833219296172701e-06,4.87942764136408e-06,4.843748536706646e-06,4.863471164213131e-06,153 +dtmc,periodic-n0025-s01729,periodic,25,1729,structure/period-warm,1.254510715479297e-08,8.098379939526967e-10,1.1883752391183032e-08,1.4919141448257404e-08,1.2427198475084913e-08,1.2684008524387826e-08,302 +dtmc,periodic-n0025-s01729,periodic,25,1729,visits/bounded-expectation/k-10,3.929024170063114e-06,2.019250485553732e-08,3.906691008957014e-06,3.94728946654747e-06,3.919867020541508e-06,3.934652658238782e-06,157 +dtmc,periodic-n0025-s01729,periodic,25,1729,visits/bounded-expectation/k-100,2.7707064401534877e-05,1.1777028259946337e-07,2.761132018349599e-05,2.7839184996258095e-05,2.7669077211325392e-05,2.7765000868759237e-05,120 +dtmc,periodic-n0025-s02718,periodic,25,2718,construction/public-consumed,3.716606438268862e-05,6.538811563486604e-08,3.710067626705376e-05,3.723022455233149e-05,3.714108803947468e-05,3.718079710581704e-05,137 +dtmc,periodic-n0025-s02718,periodic,25,2718,evolution/k-10,2.3315504706297744e-06,7.345666719809629e-09,2.32830742234892e-06,2.40676204806992e-06,2.3300635712647254e-06,2.335345298471813e-06,193 +dtmc,periodic-n0025-s02718,periodic,25,2718,evolution/k-100,8.791381121529912e-06,4.835182177027807e-08,8.760772886732581e-06,8.900270818636381e-06,8.786425153406973e-06,8.802801680392533e-06,167 +dtmc,periodic-n0025-s02718,periodic,25,2718,evolution/one-step,3.961872305491309e-07,8.62343842766414e-09,3.87560322422267e-07,4.040704108274489e-07,3.9084185038319015e-07,3.970974514010948e-07,231 +dtmc,periodic-n0025-s02718,periodic,25,2718,finite-time/n-step/k-10,4.335648440317271e-06,8.959406419764288e-09,4.3269552222653464e-06,4.344722110602712e-06,4.332941297999285e-06,4.337682555805058e-06,156 +dtmc,periodic-n0025-s02718,periodic,25,2718,finite-time/n-step/k-100,2.956932980529792e-05,3.817201583899178e-08,2.9538001302802488e-05,2.9619396476192503e-05,2.9553997727041996e-05,2.9583334476787092e-05,120 +dtmc,periodic-n0025-s02718,periodic,25,2718,finite-time/observation/k-10,0.000106311280047521,1.6960558873241793e-07,0.00010620965719684427,0.0001065646683732957,0.00010626479402847894,0.00010639373889012683,107 +dtmc,periodic-n0025-s02718,periodic,25,2718,finite-time/observation/k-100,0.0010140207835190398,9.219534279380267e-07,0.0010132530027207125,0.0010150952855058546,0.0010136250833359857,0.0010143860332363472,69 +dtmc,periodic-n0025-s02718,periodic,25,2718,finite-time/step,8.13660210060095e-07,6.2400510597598235e-09,8.092494071125934e-07,8.229775946855212e-07,8.117723381444285e-07,8.162657803531443e-07,190 +dtmc,periodic-n0025-s02718,periodic,25,2718,hitting-probability/cold-all-states,3.794665446291068e-05,1.2141039473967705e-07,3.7861403642862206e-05,3.8152693026891106e-05,3.791556935651672e-05,3.798279688488014e-05,116 +dtmc,periodic-n0025-s02718,periodic,25,2718,hitting-probability/warm-lookup,2.387842238787391e-08,2.8286039801310567e-10,2.3622389878846628e-08,2.749573188618972e-08,2.3749748583068258e-08,2.4191800919956814e-08,288 +dtmc,periodic-n0025-s02718,periodic,25,2718,hitting-time/cold-all-states,3.519559370191849e-05,6.429030181780675e-08,3.514346984034313e-05,3.532934336302181e-05,3.518193310204272e-05,3.522614133544266e-05,117 +dtmc,periodic-n0025-s02718,periodic,25,2718,hitting-time/warm-lookup,2.4313862382815883e-08,4.658716636325142e-10,2.3876193432767043e-08,2.799031016039255e-08,2.4035030885361935e-08,2.446734726523427e-08,288 +dtmc,periodic-n0025-s02718,periodic,25,2718,hitting/bounded/at-most/k-10,4.956599343807692e-06,5.8440852607876695e-08,4.91972291265649e-06,5.126236378975377e-06,4.94438787417534e-06,4.994522859630231e-06,150 +dtmc,periodic-n0025-s02718,periodic,25,2718,hitting/bounded/at-most/k-100,5.664550487901594e-06,5.929593688343682e-08,5.6117816960152024e-06,5.742592692742925e-06,5.643486234097063e-06,5.675455678763756e-06,146 +dtmc,periodic-n0025-s02718,periodic,25,2718,hitting/bounded/exact/k-10,4.795580289268716e-06,1.842759397382334e-08,4.775718386790935e-06,4.813045952964627e-06,4.790019571231443e-06,4.8000129063078895e-06,152 +dtmc,periodic-n0025-s02718,periodic,25,2718,hitting/bounded/exact/k-100,5.485067741941301e-06,3.9916337168033234e-08,5.455122903764607e-06,5.597666018807854e-06,5.469628284414249e-06,5.503035103227349e-06,148 +dtmc,periodic-n0025-s02718,periodic,25,2718,hitting/bounded/greater-than/k-10,5.12248406243415e-06,2.751836806182553e-07,4.803247100280462e-06,5.30490923395023e-06,5.0892870474074566e-06,5.158205317902862e-06,154 +dtmc,periodic-n0025-s02718,periodic,25,2718,hitting/bounded/greater-than/k-100,5.423020016214828e-06,2.650173292842224e-08,5.4036504664648815e-06,5.495864826222452e-06,5.415933768586749e-06,5.432201517514833e-06,148 +dtmc,periodic-n0025-s02718,periodic,25,2718,power/10,1.6433631233988636e-05,5.7810826102682196e-08,1.63913858659028e-05,1.659086036977109e-05,1.6418061756999682e-05,1.645359479123389e-05,154 +dtmc,periodic-n0025-s02718,periodic,25,2718,power/100,2.0278836998083592e-05,1.1181847520739658e-07,2.019475335134314e-05,2.0499165840214738e-05,2.0246970658329696e-05,2.0321947780421885e-05,150 +dtmc,periodic-n0025-s02718,periodic,25,2718,power/2,1.3245904330764142e-05,4.533559275929363e-08,1.3210902173062102e-05,1.3305997847337982e-05,1.3239903113523431e-05,1.3254007787171648e-05,158 +dtmc,periodic-n0025-s02718,periodic,25,2718,return/bounded/k-10,4.747609788561628e-06,1.3054368070861073e-07,4.621768711527408e-06,4.90544166845771e-06,4.68415811682414e-06,4.7832058044150475e-06,153 +dtmc,periodic-n0025-s02718,periodic,25,2718,return/bounded/k-100,9.288128196550089e-06,5.3085121641364974e-08,9.253386079033057e-06,9.387615533536512e-06,9.275508920790967e-06,9.301661802965102e-06,134 +dtmc,periodic-n0025-s02718,periodic,25,2718,stationary,1.5953893234379262e-05,4.008754285392331e-08,1.5922192813314754e-05,1.6035857178004725e-05,1.5943881509075356e-05,1.596573784896364e-05,129 +dtmc,periodic-n0025-s02718,periodic,25,2718,structure/classes-cold,4.5692772317202166e-06,2.7367359708590297e-08,4.548763803495085e-06,4.691339624870607e-06,4.563232540458548e-06,4.580052183499854e-06,155 +dtmc,periodic-n0025-s02718,periodic,25,2718,structure/classes-lifecycle,4.029906980065633e-05,5.6316077647691764e-08,4.026010026993056e-05,4.049164530442009e-05,4.027746921116066e-05,4.032495965792399e-05,132 +dtmc,periodic-n0025-s02718,periodic,25,2718,structure/classes-warm/access,8.58493682358153e-09,8.107271865527122e-11,8.518102285628756e-09,1.0775860489999084e-08,8.553113386792991e-09,8.658247062687634e-09,309 +dtmc,periodic-n0025-s02718,periodic,25,2718,structure/classes-warm/consumed,1.0608203495285776e-07,6.012385212252277e-10,1.0568629787003363e-07,1.1081086798898272e-07,1.0588794194583337e-07,1.0643890353945254e-07,257 +dtmc,periodic-n0025-s02718,periodic,25,2718,structure/cyclic-classes-cold,7.758223767191409e-06,1.4602722367709879e-08,7.748028444220936e-06,7.784499644357682e-06,7.75450144360945e-06,7.763119740555941e-06,144 +dtmc,periodic-n0025-s02718,periodic,25,2718,structure/cyclic-classes-warm,2.211693182510263e-06,2.3099861256560417e-09,2.210586688730581e-06,2.224623090542753e-06,2.211197820734058e-06,2.212949406508318e-06,195 +dtmc,periodic-n0025-s02718,periodic,25,2718,structure/irreducible-cold,2.60791725296744e-06,1.3157905706380814e-08,2.597559517318e-06,2.624765827357279e-06,2.6041525416076183e-06,2.6132673129736297e-06,166 +dtmc,periodic-n0025-s02718,periodic,25,2718,structure/irreducible-warm,9.593781087441452e-09,8.890203105703396e-11,9.520379099565497e-09,1.1880259183070833e-08,9.559526323600286e-09,9.705170949810465e-09,307 +dtmc,periodic-n0025-s02718,periodic,25,2718,structure/period-cold,4.886490429934358e-06,2.966580781453405e-08,4.8620724294687585e-06,4.9265334727757946e-06,4.8805784684555976e-06,4.895918824434703e-06,151 +dtmc,periodic-n0025-s02718,periodic,25,2718,structure/period-warm,1.1763099176691085e-08,1.0957799548252693e-10,1.1668731616790948e-08,1.4463597225963186e-08,1.1716302443885873e-08,1.1850824700010962e-08,302 +dtmc,periodic-n0025-s02718,periodic,25,2718,visits/bounded-expectation/k-10,4.080430683148861e-06,1.42046221781589e-07,3.962337629033115e-06,4.3675135162489316e-06,4.020066516992191e-06,4.119252703988543e-06,154 +dtmc,periodic-n0025-s02718,periodic,25,2718,visits/bounded-expectation/k-100,2.8798214196668643e-05,9.993375407705672e-07,2.7914225802864393e-05,3.090713458062199e-05,2.843027448074685e-05,2.9233535834854202e-05,119 +dtmc,periodic-n0025-s31415,periodic,25,31415,construction/public-consumed,3.716004691038203e-05,8.258902046459529e-08,3.708309167107039e-05,3.7250171805714706e-05,3.713749464646639e-05,3.718486321093985e-05,137 +dtmc,periodic-n0025-s31415,periodic,25,31415,evolution/k-10,2.323125064323682e-06,5.396095839944027e-09,2.3189542340914202e-06,2.3337921233392777e-06,2.3211708380463155e-06,2.32449195418699e-06,194 +dtmc,periodic-n0025-s31415,periodic,25,31415,evolution/k-100,8.683333483835061e-06,5.0956336106511876e-08,8.633844199134997e-06,8.738602399513752e-06,8.674024627685884e-06,8.691924946966734e-06,167 +dtmc,periodic-n0025-s31415,periodic,25,31415,evolution/one-step,3.9606264344464663e-07,9.088238134253344e-09,3.8699608668400986e-07,4.070567160240819e-07,3.944723625079272e-07,3.966670106162001e-07,231 +dtmc,periodic-n0025-s31415,periodic,25,31415,finite-time/n-step/k-10,4.43189300743765e-06,6.970151608910992e-08,4.3693320991876935e-06,4.537982871887631e-06,4.420531896987533e-06,4.449907455997763e-06,155 +dtmc,periodic-n0025-s31415,periodic,25,31415,finite-time/n-step/k-100,2.9929316412933446e-05,3.1961675698834397e-07,2.964953309856355e-05,3.033464213548395e-05,2.9791953273333578e-05,3.0055291943192002e-05,119 +dtmc,periodic-n0025-s31415,periodic,25,31415,finite-time/observation/k-10,0.00010647266369183357,3.5809799530946395e-07,0.00010623887883673053,0.00010814542985091176,0.00010633384315096272,0.00010685496446022127,106 +dtmc,periodic-n0025-s31415,periodic,25,31415,finite-time/observation/k-100,0.0010526460100663826,1.4263444297414867e-05,0.0010409238744614412,0.0010693166860922551,0.0010490510161034763,0.0010566146265773568,69 +dtmc,periodic-n0025-s31415,periodic,25,31415,finite-time/step,8.193798055886181e-07,1.260959443145541e-08,8.095099257315059e-07,8.384752113887717e-07,8.166116738441186e-07,8.239818871235498e-07,188 +dtmc,periodic-n0025-s31415,periodic,25,31415,hitting-probability/cold-all-states,3.958291435992578e-05,1.0386875491895951e-06,3.874578660273906e-05,4.181413868187148e-05,3.933276109758472e-05,4.002067636148307e-05,114 +dtmc,periodic-n0025-s31415,periodic,25,31415,hitting-probability/warm-lookup,2.6199961978594016e-08,2.3130651632746266e-09,2.4444982420307098e-08,3.413191686728147e-08,2.5817637066995982e-08,2.7398336118610212e-08,287 +dtmc,periodic-n0025-s31415,periodic,25,31415,hitting-time/cold-all-states,3.5433902452799404e-05,1.5992048647960354e-07,3.529534505468824e-05,3.565182603084069e-05,3.536385271280747e-05,3.547638086203768e-05,116 +dtmc,periodic-n0025-s31415,periodic,25,31415,hitting-time/warm-lookup,2.5668777899021406e-08,1.6646611150857675e-09,2.414254859979745e-08,2.9400109183154113e-08,2.535295240658527e-08,2.5952281238662306e-08,287 +dtmc,periodic-n0025-s31415,periodic,25,31415,hitting/bounded/at-most/k-10,4.934212443509346e-06,2.643632745331894e-08,4.912223871675549e-06,4.967662258459404e-06,4.929309115135781e-06,4.942651126750479e-06,152 +dtmc,periodic-n0025-s31415,periodic,25,31415,hitting/bounded/at-most/k-100,5.6049846262930646e-06,2.197422014577822e-08,5.590461620827759e-06,5.659346018154192e-06,5.598093163146786e-06,5.614881070150736e-06,150 +dtmc,periodic-n0025-s31415,periodic,25,31415,hitting/bounded/exact/k-10,4.825404866545496e-06,5.266822053925321e-08,4.778498392128809e-06,4.921600335082319e-06,4.802438938482241e-06,4.847713877533147e-06,153 +dtmc,periodic-n0025-s31415,periodic,25,31415,hitting/bounded/exact/k-100,5.442033436342394e-06,2.0723715893809726e-08,5.426895765512077e-06,5.479316733257251e-06,5.436127087322897e-06,5.451957874286633e-06,148 +dtmc,periodic-n0025-s31415,periodic,25,31415,hitting/bounded/greater-than/k-10,4.853039389408584e-06,6.147621219338256e-08,4.798582701464397e-06,4.925744192579295e-06,4.834271914494986e-06,4.873337181075611e-06,153 +dtmc,periodic-n0025-s31415,periodic,25,31415,hitting/bounded/greater-than/k-100,5.482442191104326e-06,7.765045556584392e-08,5.416700254759884e-06,5.604403818910229e-06,5.45728838555088e-06,5.518280462047659e-06,150 +dtmc,periodic-n0025-s31415,periodic,25,31415,power/10,1.6415663946761046e-05,5.612889718556574e-08,1.6361308139467912e-05,1.6477800151459005e-05,1.6408583194871365e-05,1.642326769594001e-05,154 +dtmc,periodic-n0025-s31415,periodic,25,31415,power/100,2.018223598225171e-05,1.0762757138954685e-07,2.008540178156951e-05,2.0309690253884417e-05,2.0150449393926316e-05,2.0212500021443703e-05,150 +dtmc,periodic-n0025-s31415,periodic,25,31415,power/2,1.3203307088654302e-05,1.3428163298929298e-08,1.3193486299900087e-05,1.3245613176225424e-05,1.3200811703766744e-05,1.3207184946642068e-05,158 +dtmc,periodic-n0025-s31415,periodic,25,31415,return/bounded/k-10,4.580428838611595e-06,4.5773622242474486e-08,4.547803319361356e-06,4.708060416416937e-06,4.564081325216658e-06,4.619749233825132e-06,154 +dtmc,periodic-n0025-s31415,periodic,25,31415,return/bounded/k-100,9.392155086033866e-06,1.3755849591352595e-07,9.27191478880004e-06,9.577230861596375e-06,9.342456105138797e-06,9.485770682586313e-06,140 +dtmc,periodic-n0025-s31415,periodic,25,31415,stationary,1.6912396844881612e-05,8.189067421225309e-07,1.6273805763846533e-05,1.8203684099598904e-05,1.6691552909541123e-05,1.7291225870315084e-05,126 +dtmc,periodic-n0025-s31415,periodic,25,31415,structure/classes-cold,4.457764127306907e-06,9.308519283886636e-09,4.450898012632714e-06,4.476113879883831e-06,4.455144600252234e-06,4.4621445244717365e-06,155 +dtmc,periodic-n0025-s31415,periodic,25,31415,structure/classes-lifecycle,4.0346440382638616e-05,3.929247256047365e-08,4.031859274087313e-05,4.0482305780108316e-05,4.0332677976011404e-05,4.036168103405626e-05,136 +dtmc,periodic-n0025-s31415,periodic,25,31415,structure/classes-warm/access,8.639916955596644e-09,1.3601852530312205e-10,8.525501648193124e-09,1.0775860489999084e-08,8.573052909850575e-09,8.76127747005273e-09,309 +dtmc,periodic-n0025-s31415,periodic,25,31415,structure/classes-warm/consumed,1.0651311932555909e-07,6.929745391678541e-10,1.0593275283373663e-07,1.132812030846253e-07,1.0620672580473766e-07,1.0713357063199922e-07,257 +dtmc,periodic-n0025-s31415,periodic,25,31415,structure/cyclic-classes-cold,7.765043516304683e-06,7.523640497474694e-08,7.702324714375812e-06,8.01808957785784e-06,7.73737472053127e-06,7.790578444465478e-06,143 +dtmc,periodic-n0025-s31415,periodic,25,31415,structure/cyclic-classes-warm,2.2831115659625667e-06,5.863871229728145e-08,2.2385959289320705e-06,2.390425867849478e-06,2.2640186590447185e-06,2.3178970886366536e-06,193 +dtmc,periodic-n0025-s31415,periodic,25,31415,structure/irreducible-cold,2.5158304345620764e-06,1.314704101483853e-08,2.495819723462465e-06,2.5266055609747604e-06,2.5097346669823236e-06,2.5205716990028587e-06,167 +dtmc,periodic-n0025-s31415,periodic,25,31415,structure/irreducible-warm,9.619190475437283e-09,1.1593361129565041e-10,9.519634748198153e-09,1.1998373897618687e-08,9.567024455953336e-09,9.768557755969758e-09,307 +dtmc,periodic-n0025-s31415,periodic,25,31415,structure/period-cold,4.798517390251315e-06,3.59300790319504e-08,4.776247703828894e-06,4.901284980380305e-06,4.790307033000144e-06,4.811243729129659e-06,151 +dtmc,periodic-n0025-s31415,periodic,25,31415,structure/period-warm,1.2017721125593656e-08,3.516979189602751e-10,1.170304980124441e-08,1.4903847701274432e-08,1.1918890823331007e-08,1.2213425628442365e-08,301 +dtmc,periodic-n0025-s31415,periodic,25,31415,visits/bounded-expectation/k-10,3.981752118790227e-06,4.9691835002225847e-08,3.947935953289143e-06,4.116395570418384e-06,3.9714514774929605e-06,4.022955051665802e-06,156 +dtmc,periodic-n0025-s31415,periodic,25,31415,visits/bounded-expectation/k-100,2.8815181829723652e-05,9.369332626396598e-07,2.808774062263297e-05,3.1079300970304755e-05,2.8534183829006825e-05,2.9228216896218988e-05,117 +dtmc,periodic-n0050-s01729,periodic,50,1729,construction/public-consumed,0.0001451794019988444,3.9815187055471167e-07,0.00014492178901523482,0.0001459449619004719,0.00014507730252501605,0.000145297336159274,109 +dtmc,periodic-n0050-s01729,periodic,50,1729,evolution/k-10,4.414593259019326e-06,3.844224540919416e-08,4.384139409876982e-06,4.4812188075477446e-06,4.399319307297689e-06,4.433901965519001e-06,181 +dtmc,periodic-n0050-s01729,periodic,50,1729,evolution/k-100,2.0784671884030105e-05,2.0871476524255328e-07,2.063878714689568e-05,2.1244215329513987e-05,2.0704892362627937e-05,2.08918270520651e-05,149 +dtmc,periodic-n0050-s01729,periodic,50,1729,evolution/one-step,7.468541601459341e-07,1.2745423771196948e-08,7.353360472683109e-07,7.684228386586675e-07,7.433861605127367e-07,7.501616273523392e-07,217 +dtmc,periodic-n0050-s01729,periodic,50,1729,finite-time/n-step/k-10,5.874882750471807e-06,1.7712867895009782e-08,5.86047029835835e-06,5.8942276718571985e-06,5.869655140640008e-06,5.880788756106298e-06,149 +dtmc,periodic-n0050-s01729,periodic,50,1729,finite-time/n-step/k-100,4.3174546133064164e-05,1.0710182431494808e-07,4.309136302108951e-05,4.360669117886573e-05,4.312167262413255e-05,4.32466643720751e-05,108 +dtmc,periodic-n0050-s01729,periodic,50,1729,finite-time/observation/k-10,0.00029925049232823247,1.9308420007513793e-07,0.0002990606853522564,0.00029945192654849966,0.0002991805558849592,0.0002993297621640696,84 +dtmc,periodic-n0050-s01729,periodic,50,1729,finite-time/observation/k-100,0.002908386935439286,5.597629679537225e-06,0.002902789305759749,0.002913883297878783,0.0029069291494758518,0.0029120593891194505,49 +dtmc,periodic-n0050-s01729,periodic,50,1729,finite-time/step,8.265860797000859e-07,6.750365285449499e-09,8.19685065174756e-07,8.332142550941734e-07,8.248711621883341e-07,8.284461764800576e-07,189 +dtmc,periodic-n0050-s01729,periodic,50,1729,hitting-probability/cold-all-states,9.999725772368331e-05,1.2896546611036144e-07,9.991661944237035e-05,0.00010024590010289103,9.997309148432044e-05,0.00010006683757792245,93 +dtmc,periodic-n0050-s01729,periodic,50,1729,hitting-probability/warm-lookup,2.3795520937018613e-08,2.306917480977285e-10,2.3616292725532346e-08,2.7510042277067908e-08,2.368150297934981e-08,2.416924991458428e-08,288 +dtmc,periodic-n0050-s01729,periodic,50,1729,hitting-time/cold-all-states,9.553025840233042e-05,1.423227429433728e-07,9.539220777768938e-05,9.568215183982695e-05,9.549228057437078e-05,9.557226633963486e-05,93 +dtmc,periodic-n0050-s01729,periodic,50,1729,hitting-time/warm-lookup,2.418662702258811e-08,3.3791957031959855e-10,2.3879711463007045e-08,2.8404530182302932e-08,2.401038279599833e-08,2.4523620260970348e-08,288 +dtmc,periodic-n0050-s01729,periodic,50,1729,hitting/bounded/at-most/k-10,6.710539967600262e-06,3.435152489203085e-07,6.38644880142582e-06,7.368045272145742e-06,6.549349442745248e-06,6.93147908050445e-06,148 +dtmc,periodic-n0050-s01729,periodic,50,1729,hitting/bounded/at-most/k-100,1.3373374154368899e-05,2.0957097175597555e-08,1.335769143385311e-05,1.3414001258728931e-05,1.3369226727400985e-05,1.3381849427358498e-05,132 +dtmc,periodic-n0050-s01729,periodic,50,1729,hitting/bounded/exact/k-10,6.287130916325812e-06,1.1667117728358412e-08,6.27862550506499e-06,6.303019446448409e-06,6.283932284022124e-06,6.290144611684443e-06,148 +dtmc,periodic-n0050-s01729,periodic,50,1729,hitting/bounded/exact/k-100,1.3171453302147598e-05,3.523280889717952e-08,1.3139711997225556e-05,1.3230865518652797e-05,1.3161974690948498e-05,1.3186563455296847e-05,132 +dtmc,periodic-n0050-s01729,periodic,50,1729,hitting/bounded/greater-than/k-10,6.339269540538745e-06,1.1039743389730704e-08,6.330248346438358e-06,6.353857989543704e-06,6.336249167692255e-06,6.341779439604123e-06,148 +dtmc,periodic-n0050-s01729,periodic,50,1729,hitting/bounded/greater-than/k-100,1.3186731502826942e-05,2.574104681269979e-08,1.3157843281269857e-05,1.3205531623888029e-05,1.3181547309910313e-05,1.3190035175424641e-05,133 +dtmc,periodic-n0050-s01729,periodic,50,1729,power/10,4.7562957397082826e-05,4.127106053316495e-07,4.719843027198785e-05,4.801882072954938e-05,4.7460898914194596e-05,4.7674212757980367e-05,132 +dtmc,periodic-n0050-s01729,periodic,50,1729,power/100,5.772257339857403e-05,5.018451385608163e-07,5.741759034895545e-05,5.837305714639144e-05,5.761353949213293e-05,5.79247082405634e-05,128 +dtmc,periodic-n0050-s01729,periodic,50,1729,power/2,4.055327334277253e-05,1.9818547746654978e-07,4.03602362866786e-05,4.0753790472646345e-05,4.051703811879039e-05,4.059629416101814e-05,135 +dtmc,periodic-n0050-s01729,periodic,50,1729,return/bounded/k-10,6.109839225907556e-06,2.365385061645318e-08,6.0878931883771025e-06,6.140273233706301e-06,6.1027144284553804e-06,6.117400827802597e-06,149 +dtmc,periodic-n0050-s01729,periodic,50,1729,return/bounded/k-100,2.3936147509301278e-05,2.8977277448064025e-08,2.390808252144664e-05,2.396664242525408e-05,2.3926010779926882e-05,2.3950748078632185e-05,121 +dtmc,periodic-n0050-s01729,periodic,50,1729,stationary,6.456555657896465e-05,8.697769738131905e-08,6.450281400394364e-05,6.475606593691434e-05,6.454075683338813e-05,6.460471527783999e-05,100 +dtmc,periodic-n0050-s01729,periodic,50,1729,structure/classes-cold,7.595182227854071e-06,2.08214231182841e-08,7.580799260876085e-06,7.631097650363671e-06,7.59027240010688e-06,7.5995857413444255e-06,144 +dtmc,periodic-n0050-s01729,periodic,50,1729,structure/classes-lifecycle,0.00015124569544958184,3.486963967472658e-07,0.00015087513889639191,0.00015152822778329624,0.00015115810331643432,0.0001513474822411366,108 +dtmc,periodic-n0050-s01729,periodic,50,1729,structure/classes-warm/access,8.670984463447925e-09,1.5428295622361193e-10,8.52493643549188e-09,1.0958350079211717e-08,8.623981323687805e-09,8.737317606959454e-09,309 +dtmc,periodic-n0050-s01729,periodic,50,1729,structure/classes-warm/consumed,2.3594863501676743e-07,3.7066697374608827e-09,2.3235270772108625e-07,2.457826917964047e-07,2.3398466614989838e-07,2.3706544631304558e-07,241 +dtmc,periodic-n0050-s01729,periodic,50,1729,structure/cyclic-classes-cold,1.3899445880321143e-05,3.53315771763226e-08,1.3872660192975966e-05,1.3954275062038807e-05,1.3891146945040005e-05,1.3913516099628695e-05,132 +dtmc,periodic-n0050-s01729,periodic,50,1729,structure/cyclic-classes-warm,4.364956432065383e-06,6.247743285973687e-09,4.358171056766792e-06,4.370155697680766e-06,4.36329392564798e-06,4.366236297707808e-06,181 +dtmc,periodic-n0050-s01729,periodic,50,1729,structure/irreducible-cold,3.931749549154993e-06,9.111325384141243e-09,3.9216551337111535e-06,3.940470888642822e-06,3.929211223713213e-06,3.933014612591417e-06,158 +dtmc,periodic-n0050-s01729,periodic,50,1729,structure/irreducible-warm,9.623871303494028e-09,1.235883338753517e-10,9.518707725924218e-09,1.1792925154926099e-08,9.585943017297515e-09,9.680310884076935e-09,307 +dtmc,periodic-n0050-s01729,periodic,50,1729,structure/period-cold,8.425332370494396e-06,1.8737945753054037e-08,8.406970796263399e-06,8.444081683832854e-06,8.418814799676031e-06,8.43267808968742e-06,142 +dtmc,periodic-n0050-s01729,periodic,50,1729,structure/period-warm,1.1741510772820612e-08,8.14071231446086e-11,1.1668453007760778e-08,1.4424153338527725e-08,1.1716606152691648e-08,1.1829171452653793e-08,302 +dtmc,periodic-n0050-s01729,periodic,50,1729,visits/bounded-expectation/k-10,5.226225721058231e-06,1.3358217212512625e-08,5.213772305823671e-06,5.240773475298983e-06,5.22226231686514e-06,5.22935877144972e-06,152 +dtmc,periodic-n0050-s01729,periodic,50,1729,visits/bounded-expectation/k-100,4.0876781346676277e-05,3.595705679723527e-08,4.08442699778133e-05,4.092497057184869e-05,4.086474208517026e-05,4.088437350130683e-05,110 +dtmc,periodic-n0050-s02718,periodic,50,2718,construction/public-consumed,0.00014488376142584127,1.49376929108329e-07,0.00014475000000769092,0.00014504870399832724,0.00014481818167647967,0.00014497671569081242,109 +dtmc,periodic-n0050-s02718,periodic,50,2718,evolution/k-10,4.753230873925181e-06,1.1974602400208876e-07,4.4051392690171325e-06,4.864869611885618e-06,4.733778680283719e-06,4.7836211008188455e-06,181 +dtmc,periodic-n0050-s02718,periodic,50,2718,evolution/k-100,2.0526515348165326e-05,3.5421815771434994e-08,2.0500171298374492e-05,2.0730769252762773e-05,2.0515591525934926e-05,2.053719153380668e-05,149 +dtmc,periodic-n0050-s02718,periodic,50,2718,evolution/one-step,7.485857300011361e-07,1.5097553608004895e-08,7.335092061655816e-07,7.642942688916745e-07,7.461121027240436e-07,7.507130523597148e-07,216 +dtmc,periodic-n0050-s02718,periodic,50,2718,finite-time/n-step/k-10,5.864332541805995e-06,1.229200881060004e-08,5.852952453199354e-06,5.87843333407506e-06,5.860272699929014e-06,5.86784268594592e-06,149 +dtmc,periodic-n0050-s02718,periodic,50,2718,finite-time/n-step/k-100,4.297209436218725e-05,2.8144035095144205e-08,4.2947648551254985e-05,4.301321422780289e-05,4.296659608371556e-05,4.2980623564872784e-05,109 +dtmc,periodic-n0050-s02718,periodic,50,2718,finite-time/observation/k-10,0.0003032080177455999,3.4298273776957582e-06,0.00029955088709054207,0.00030528823931707025,0.00030046990649043793,0.00030449993723510383,84 +dtmc,periodic-n0050-s02718,periodic,50,2718,finite-time/observation/k-100,0.002908094188846324,5.5101058366573835e-06,0.002903575731166215,0.0029147425653797614,0.002905689487692364,0.0029116111141370814,49 +dtmc,periodic-n0050-s02718,periodic,50,2718,finite-time/step,8.230166766198649e-07,3.882640138723139e-09,8.202116769524774e-07,8.293586275116964e-07,8.221234556943475e-07,8.242191198124549e-07,189 +dtmc,periodic-n0050-s02718,periodic,50,2718,hitting-probability/cold-all-states,0.00010021029844541441,1.5524285892407996e-07,0.00010010775947936397,0.00010050020212550873,0.00010018544845229042,0.0001002732510991896,93 +dtmc,periodic-n0050-s02718,periodic,50,2718,hitting-probability/warm-lookup,2.3721263144259507e-08,1.1146097650444244e-10,2.3623065794869373e-08,2.6738501405697738e-08,2.3687424452718694e-08,2.3778871035114882e-08,288 +dtmc,periodic-n0050-s02718,periodic,50,2718,hitting-time/cold-all-states,9.542986778174772e-05,5.9518482119428197e-08,9.53836408443749e-05,9.556110308039933e-05,9.540480585033153e-05,9.54656077184431e-05,93 +dtmc,periodic-n0050-s02718,periodic,50,2718,hitting-time/warm-lookup,2.3995287380327977e-08,1.3484214248003093e-10,2.3886808969369065e-08,2.745375670617195e-08,2.3950974422799605e-08,2.4216533750267445e-08,288 +dtmc,periodic-n0050-s02718,periodic,50,2718,hitting/bounded/at-most/k-10,6.378760909485879e-06,1.2256598624127095e-08,6.3689429905255336e-06,6.395314068112668e-06,6.376777960495932e-06,6.384378615684436e-06,148 +dtmc,periodic-n0050-s02718,periodic,50,2718,hitting/bounded/at-most/k-100,1.3386200558638733e-05,2.090715438927643e-08,1.336783009297939e-05,1.3408962640178558e-05,1.3380161305311831e-05,1.3394949102028932e-05,132 +dtmc,periodic-n0050-s02718,periodic,50,2718,hitting/bounded/exact/k-10,6.305539464212563e-06,1.5357933624702117e-08,6.286867552690262e-06,6.317992017534266e-06,6.302005203906447e-06,6.310315137631792e-06,148 +dtmc,periodic-n0050-s02718,periodic,50,2718,hitting/bounded/exact/k-100,1.317940712919065e-05,1.0291782969927026e-08,1.3170053954331242e-05,1.3193996452716036e-05,1.3176404466829706e-05,1.3183176955607557e-05,132 +dtmc,periodic-n0050-s02718,periodic,50,2718,hitting/bounded/greater-than/k-10,6.309096079266639e-06,1.4157674633379258e-08,6.297102872680676e-06,6.332245877264354e-06,6.304434816990847e-06,6.31490976191931e-06,148 +dtmc,periodic-n0050-s02718,periodic,50,2718,hitting/bounded/greater-than/k-100,1.3161978853097268e-05,1.25260703819765e-08,1.3149454145567473e-05,1.3176027636475645e-05,1.3157856142117198e-05,1.3165209658335948e-05,133 +dtmc,periodic-n0050-s02718,periodic,50,2718,power/10,4.6813327555914495e-05,1.2631609998594044e-07,4.668725570289618e-05,4.6939396413202366e-05,4.678383921221101e-05,4.683799216080059e-05,132 +dtmc,periodic-n0050-s02718,periodic,50,2718,power/100,5.7043066702871805e-05,1.7360064759741132e-07,5.692267194115607e-05,5.734139565805652e-05,5.700558043235951e-05,5.711016083843387e-05,128 +dtmc,periodic-n0050-s02718,periodic,50,2718,power/2,4.0139826824626184e-05,2.7872959612604758e-08,4.011711208725952e-05,4.0195030531604416e-05,4.013045454783865e-05,4.014786254408996e-05,136 +dtmc,periodic-n0050-s02718,periodic,50,2718,return/bounded/k-10,6.084505176389228e-06,1.0106549210032041e-08,6.0761645314279606e-06,6.09722930541331e-06,6.0830246849883835e-06,6.088851793703386e-06,149 +dtmc,periodic-n0050-s02718,periodic,50,2718,return/bounded/k-100,2.3864163602263343e-05,2.257183897771755e-08,2.3841285534823935e-05,2.3881853353073396e-05,2.3855356951518095e-05,2.386970333575916e-05,121 +dtmc,periodic-n0050-s02718,periodic,50,2718,stationary,6.453022643404108e-05,5.074458517016008e-08,6.448416827179213e-05,6.46014266770074e-05,6.451506008868566e-05,6.45506992921857e-05,100 +dtmc,periodic-n0050-s02718,periodic,50,2718,structure/classes-cold,7.56736065003403e-06,2.5199320152574624e-08,7.548212132069475e-06,7.597239234976479e-06,7.559623731096967e-06,7.573129051144569e-06,144 +dtmc,periodic-n0050-s02718,periodic,50,2718,structure/classes-lifecycle,0.00015079280398797623,1.0421176325979792e-07,0.00015071036781508197,0.0001509630248619942,0.00015076650826634504,0.00015083683649769975,109 +dtmc,periodic-n0050-s02718,periodic,50,2718,structure/classes-warm/access,8.595482928461125e-09,9.779628442541647e-11,8.519714479952326e-09,1.094294815100258e-08,8.558271787309496e-09,8.66198217835361e-09,309 +dtmc,periodic-n0050-s02718,periodic,50,2718,structure/classes-warm/consumed,2.3486035686959861e-07,3.0351303750204183e-09,2.3206257533988915e-07,2.41580598543933e-07,2.331666067209534e-07,2.3559386522145192e-07,241 +dtmc,periodic-n0050-s02718,periodic,50,2718,structure/cyclic-classes-cold,1.4001442356254183e-05,9.518307255329289e-08,1.3925710543192914e-05,1.448437127361434e-05,1.3954512627031999e-05,1.4031728519142509e-05,132 +dtmc,periodic-n0050-s02718,periodic,50,2718,structure/cyclic-classes-warm,4.366856267472064e-06,3.6315169254061864e-09,4.3651617751572695e-06,4.3810679785256246e-06,4.3664060698887156e-06,4.367611039941122e-06,181 +dtmc,periodic-n0050-s02718,periodic,50,2718,structure/irreducible-cold,3.936121411740319e-06,6.769807157812338e-09,3.929891880633505e-06,3.945042379225207e-06,3.934517843613447e-06,3.938558904714048e-06,158 +dtmc,periodic-n0050-s02718,periodic,50,2718,structure/irreducible-warm,9.745866885950867e-09,2.2834821172741164e-10,9.531450112139687e-09,1.2134754648317347e-08,9.70101930757305e-09,9.834601209285149e-09,307 +dtmc,periodic-n0050-s02718,periodic,50,2718,structure/period-cold,8.402870894308143e-06,2.089263907863109e-08,8.384646910626033e-06,8.426126314459437e-06,8.397007065197348e-06,8.409229763560646e-06,142 +dtmc,periodic-n0050-s02718,periodic,50,2718,structure/period-warm,1.180861064889204e-08,1.5419950666500612e-10,1.1668154309905523e-08,1.4652019612245508e-08,1.1737896845535822e-08,1.190652816526754e-08,301 +dtmc,periodic-n0050-s02718,periodic,50,2718,visits/bounded-expectation/k-10,5.193694943954466e-06,9.419406711263469e-09,5.184314345407925e-06,5.203059458171088e-06,5.190208901848788e-06,5.195915419550355e-06,152 +dtmc,periodic-n0050-s02718,periodic,50,2718,visits/bounded-expectation/k-100,4.0859507004681385e-05,2.5576943667015705e-08,4.0835244845755356e-05,4.0886098444101044e-05,4.085214932915434e-05,4.0865554991695615e-05,110 +dtmc,periodic-n0050-s31415,periodic,50,31415,construction/public-consumed,0.00014504649379322755,1.0128283219076428e-07,0.00014495000020057583,0.0001451671275748336,0.00014500420074909927,0.00014507440428280168,109 +dtmc,periodic-n0050-s31415,periodic,50,31415,evolution/k-10,4.393943196522411e-06,7.966696366394335e-09,4.386340678618179e-06,4.40342254022829e-06,4.392233010872571e-06,4.39545402454666e-06,181 +dtmc,periodic-n0050-s31415,periodic,50,31415,evolution/k-100,2.06645876460243e-05,1.6379910028682795e-07,2.0568649355908586e-05,2.270129644262426e-05,2.0614452549562897e-05,2.0971154579176353e-05,147 +dtmc,periodic-n0050-s31415,periodic,50,31415,evolution/one-step,7.494380134007181e-07,1.4446017074801193e-08,7.349448587637971e-07,7.596055191864635e-07,7.360039988363365e-07,7.508080839702125e-07,218 +dtmc,periodic-n0050-s31415,periodic,50,31415,finite-time/n-step/k-10,5.857066883306418e-06,1.3987894315525403e-08,5.843197076240241e-06,5.8710547776219434e-06,5.853485411287031e-06,5.862038713671918e-06,149 +dtmc,periodic-n0050-s31415,periodic,50,31415,finite-time/n-step/k-100,4.3132260867359066e-05,1.0120563641070562e-07,4.304737451507429e-05,4.3306383148662464e-05,4.308470392398938e-05,4.318934335315611e-05,108 +dtmc,periodic-n0050-s31415,periodic,50,31415,finite-time/observation/k-10,0.00029940435425096956,2.318170046553946e-07,0.0002992226907046078,0.00029982679937052794,0.00029933201024121806,0.00029951104149339035,84 +dtmc,periodic-n0050-s31415,periodic,50,31415,finite-time/observation/k-100,0.002916123428024418,5.861059443781295e-06,0.0029105548987306815,0.0029222481396226655,0.0029127338709640164,0.002918134599615139,49 +dtmc,periodic-n0050-s31415,periodic,50,31415,finite-time/step,8.424223454825875e-07,4.7939331492215345e-09,8.37941068964891e-07,8.472162786318091e-07,8.41383115146999e-07,8.43316890255299e-07,189 +dtmc,periodic-n0050-s31415,periodic,50,31415,hitting-probability/cold-all-states,0.00010023598733823746,1.1070615004121591e-07,0.0001001605282939233,0.0001004012289137862,0.00010021533752377663,0.00010028025003737726,93 +dtmc,periodic-n0050-s31415,periodic,50,31415,hitting-probability/warm-lookup,2.3756479482499423e-08,1.496669913052393e-10,2.3637676014692646e-08,2.710179741547235e-08,2.3693361709978283e-08,2.3902638456484478e-08,288 +dtmc,periodic-n0050-s31415,periodic,50,31415,hitting-time/cold-all-states,9.554502262011626e-05,1.0264937597911645e-07,9.545945202874069e-05,9.56867874125377e-05,9.549643741031125e-05,9.557563462294638e-05,93 +dtmc,periodic-n0050-s31415,periodic,50,31415,hitting-time/warm-lookup,2.408134534006004e-08,1.8379349039434086e-10,2.3911623645301223e-08,2.7299197304765553e-08,2.399550966988411e-08,2.4191442171602936e-08,288 +dtmc,periodic-n0050-s31415,periodic,50,31415,hitting/bounded/at-most/k-10,6.373900965429275e-06,1.9170497857745567e-08,6.3599457311291275e-06,6.402961271642535e-06,6.3708344534376945e-06,6.381828243432698e-06,148 +dtmc,periodic-n0050-s31415,periodic,50,31415,hitting/bounded/at-most/k-100,1.3435995436281353e-05,1.9452005591746375e-08,1.3419851260270834e-05,1.3458818819682307e-05,1.3429217825146163e-05,1.3442914242098869e-05,132 +dtmc,periodic-n0050-s31415,periodic,50,31415,hitting/bounded/exact/k-10,6.339735563106814e-06,1.0923538507513572e-08,6.331542788160938e-06,6.353745779179445e-06,6.336381016272274e-06,6.3425333756405546e-06,148 +dtmc,periodic-n0050-s31415,periodic,50,31415,hitting/bounded/exact/k-100,1.3219283831371802e-05,2.8264742927721742e-08,1.3187972833223354e-05,1.3240963689704815e-05,1.321222580296277e-05,1.3224907600069567e-05,133 +dtmc,periodic-n0050-s31415,periodic,50,31415,hitting/bounded/greater-than/k-10,6.317315656346289e-06,8.580028667388466e-09,6.308936137986011e-06,6.326255478295888e-06,6.315451793680821e-06,6.3203455871938746e-06,148 +dtmc,periodic-n0050-s31415,periodic,50,31415,hitting/bounded/greater-than/k-100,1.320587398367934e-05,1.9712229898972367e-08,1.3189472659507064e-05,1.3234579359720411e-05,1.3198357746226802e-05,1.3214262009303018e-05,133 +dtmc,periodic-n0050-s31415,periodic,50,31415,power/10,4.6787101611340135e-05,8.976088210445923e-08,4.6696091281545516e-05,4.6867253217555936e-05,4.676905564402977e-05,4.681470631516681e-05,132 +dtmc,periodic-n0050-s31415,periodic,50,31415,power/100,5.6773095465640906e-05,1.8232793895034413e-07,5.663105927089069e-05,5.701361821428832e-05,5.673356031639928e-05,5.681648697479967e-05,128 +dtmc,periodic-n0050-s31415,periodic,50,31415,power/2,4.0173946705609275e-05,3.0693056855182874e-08,4.015166700981326e-05,4.023358755255365e-05,4.01667692460508e-05,4.0181532506339574e-05,136 +dtmc,periodic-n0050-s31415,periodic,50,31415,return/bounded/k-10,6.093034592533012e-06,1.145179715476538e-08,6.080831234403908e-06,6.103503675847299e-06,6.090389052844589e-06,6.0944746081734334e-06,148 +dtmc,periodic-n0050-s31415,periodic,50,31415,return/bounded/k-100,2.3926551037813338e-05,2.6340289059049207e-08,2.3902907695131588e-05,2.3953189156600274e-05,2.3919421495989928e-05,2.393714675815114e-05,121 +dtmc,periodic-n0050-s31415,periodic,50,31415,stationary,6.475945178900156e-05,4.7731220690322266e-08,6.472277855209541e-05,6.481650010835483e-05,6.474626356516075e-05,6.477143751418296e-05,100 +dtmc,periodic-n0050-s31415,periodic,50,31415,structure/classes-cold,7.719462262467637e-06,1.6037802804328138e-08,7.706111024033226e-06,7.744691679418028e-06,7.714023804718643e-06,7.726287419375564e-06,144 +dtmc,periodic-n0050-s31415,periodic,50,31415,structure/classes-lifecycle,0.00015088876400645194,1.1500948729226699e-07,0.00015080868218898434,0.00015104866664235791,0.00015085332659861794,0.0001509410658878838,109 +dtmc,periodic-n0050-s31415,periodic,50,31415,structure/classes-warm/access,8.645076488525614e-09,1.2572819207771075e-10,8.527792429312588e-09,1.0775860489999084e-08,8.57795410553406e-09,8.70936909976378e-09,309 +dtmc,periodic-n0050-s31415,periodic,50,31415,structure/classes-warm/consumed,2.3369101958379778e-07,1.474045449490681e-09,2.3250439009483165e-07,2.4303654493777934e-07,2.3308560128387047e-07,2.3477239845841753e-07,240 +dtmc,periodic-n0050-s31415,periodic,50,31415,structure/cyclic-classes-cold,1.3988278822836366e-05,3.557650572350921e-08,1.3961073565325798e-05,1.405346138192538e-05,1.3979995856061578e-05,1.400137860349719e-05,131 +dtmc,periodic-n0050-s31415,periodic,50,31415,structure/cyclic-classes-warm,4.3706170608726826e-06,4.185619263986635e-09,4.367962604143482e-06,4.3844594934804215e-06,4.369341119035893e-06,4.372173738744804e-06,181 +dtmc,periodic-n0050-s31415,periodic,50,31415,structure/irreducible-cold,3.989053212711863e-06,9.852366196267598e-09,3.9792008465155956e-06,3.998065620974871e-06,3.985692312196743e-06,3.9912477592833284e-06,157 +dtmc,periodic-n0050-s31415,periodic,50,31415,structure/irreducible-warm,9.584011500296882e-09,8.10875380265621e-11,9.527544416132945e-09,1.1917407438578027e-08,9.557248815095569e-09,9.707725433815496e-09,307 +dtmc,periodic-n0050-s31415,periodic,50,31415,structure/period-cold,8.517194781571867e-06,2.3463304134749966e-08,8.495003441664857e-06,8.548312061373382e-06,8.51038538922484e-06,8.52432058243047e-06,142 +dtmc,periodic-n0050-s31415,periodic,50,31415,structure/period-warm,1.177537312362685e-08,1.0712897947715633e-10,1.1682664831503521e-08,1.4461303945335909e-08,1.1734174935485857e-08,1.1887661978269969e-08,302 +dtmc,periodic-n0050-s31415,periodic,50,31415,visits/bounded-expectation/k-10,5.186029326989062e-06,1.1876185835510496e-08,5.17547124792554e-06,5.201290674877407e-06,5.182621123183465e-06,5.1902217203714145e-06,152 +dtmc,periodic-n0050-s31415,periodic,50,31415,visits/bounded-expectation/k-100,4.086956101914583e-05,3.351446876705117e-08,4.083978999398625e-05,4.090835136594251e-05,4.085956240158935e-05,4.0879392626784166e-05,110 +dtmc,periodic-n0100-s01729,periodic,100,1729,construction/public-consumed,0.0005851377225351623,4.033677719740645e-07,0.0005843253617987354,0.0005854404085786433,0.0005849673500051722,0.0005852894744174065,81 +dtmc,periodic-n0100-s01729,periodic,100,1729,evolution/k-10,1.014891079143282e-05,1.604448398159857e-08,1.0135932653573656e-05,1.0174610569156259e-05,1.0146221860522156e-05,1.015227166612463e-05,164 +dtmc,periodic-n0100-s01729,periodic,100,1729,evolution/k-100,9.513850754492507e-05,7.699045361864772e-08,9.507007176539497e-05,9.522173778774838e-05,9.511793333444722e-05,9.516087734840987e-05,118 +dtmc,periodic-n0100-s01729,periodic,100,1729,evolution/one-step,1.6081342728813102e-06,7.812533443393788e-09,1.6029026426801598e-06,1.634274676202636e-06,1.604654449706323e-06,1.616792317591528e-06,202 +dtmc,periodic-n0100-s01729,periodic,100,1729,finite-time/n-step/k-10,8.885423994797748e-06,2.5835963690053117e-08,8.861046461831956e-06,8.91425055589874e-06,8.877917608929006e-06,8.89331641498483e-06,141 +dtmc,periodic-n0100-s01729,periodic,100,1729,finite-time/n-step/k-100,7.01361459575919e-05,5.001275691664513e-08,7.00888459802286e-05,7.020419201919406e-05,7.011960001869334e-05,7.014856055320706e-05,99 +dtmc,periodic-n0100-s01729,periodic,100,1729,finite-time/observation/k-10,0.0009798403626897134,2.879929916012368e-06,0.0009764053631277585,0.0009826749461353756,0.0009785659351985454,0.0009814450154080987,61 +dtmc,periodic-n0100-s01729,periodic,100,1729,finite-time/observation/k-100,0.008894260778712729,1.1862218282962522e-05,0.008883076908205112,0.008905813580834851,0.008888622327151919,0.00890174508211203,31 +dtmc,periodic-n0100-s01729,periodic,100,1729,finite-time/step,8.782979940796004e-07,1.7885745724238032e-08,8.596694897278213e-07,8.932537583641182e-07,8.707355270732422e-07,8.800659879000937e-07,188 +dtmc,periodic-n0100-s01729,periodic,100,1729,hitting-probability/cold-all-states,0.0003020461474618599,1.1853920570214333e-06,0.0003011621792832138,0.0003124964309768844,0.0003014631494582513,0.00030442713363636127,68 +dtmc,periodic-n0100-s01729,periodic,100,1729,hitting-probability/warm-lookup,2.3931369267851187e-08,3.016240334739985e-10,2.3645264587569754e-08,2.6943249274208727e-08,2.379508887655934e-08,2.4048765326607818e-08,288 +dtmc,periodic-n0100-s01729,periodic,100,1729,hitting-time/cold-all-states,0.0002929305507374617,4.746473449941603e-07,0.0002926056662598031,0.0002945840393434852,0.00029276250592452944,0.000293169081574195,69 +dtmc,periodic-n0100-s01729,periodic,100,1729,hitting-time/warm-lookup,2.4090678057636106e-08,1.9474075882526308e-10,2.3918742220060233e-08,2.7102703578691698e-08,2.4015280505214684e-08,2.4235686724757923e-08,288 +dtmc,periodic-n0100-s01729,periodic,100,1729,hitting/bounded/at-most/k-10,9.59716271609068e-06,4.556728526949862e-08,9.556525505028383e-06,9.663287510976395e-06,9.583457050701747e-06,9.606506056718471e-06,139 +dtmc,periodic-n0100-s01729,periodic,100,1729,hitting/bounded/at-most/k-100,3.9586509190389495e-05,5.248031776766129e-08,3.954377689660686e-05,3.96449554795868e-05,3.957413965671474e-05,3.960408260657763e-05,110 +dtmc,periodic-n0100-s01729,periodic,100,1729,hitting/bounded/exact/k-10,9.556155418977141e-06,2.297058113311413e-08,9.534024173711034e-06,9.582685578487075e-06,9.550197962985448e-06,9.561120991412089e-06,139 +dtmc,periodic-n0100-s01729,periodic,100,1729,hitting/bounded/exact/k-100,3.925503132808389e-05,3.755398767071237e-08,3.9227309281202695e-05,3.9303828013337006e-05,3.924462526769456e-05,3.9266172035407e-05,111 +dtmc,periodic-n0100-s01729,periodic,100,1729,hitting/bounded/greater-than/k-10,9.561769436292064e-06,1.6435519970667734e-08,9.547297451134282e-06,9.581572272632277e-06,9.557388130040257e-06,9.565592581308575e-06,139 +dtmc,periodic-n0100-s01729,periodic,100,1729,hitting/bounded/greater-than/k-100,3.9089978364405825e-05,3.2127832573854056e-08,3.90695554320448e-05,3.914795871380539e-05,3.9078381342198895e-05,3.910763818263755e-05,111 +dtmc,periodic-n0100-s01729,periodic,100,1729,power/10,0.00016575319960750114,1.7532909079135165e-07,0.00016559795981792186,0.00016594436004783753,0.00016571657585752567,0.0001658256330671881,106 +dtmc,periodic-n0100-s01729,periodic,100,1729,power/100,0.0002239502922586844,1.5467088253125137e-05,0.0002083291299377041,0.0002388692485624233,0.0002180505952786743,0.00022871236083205385,100 +dtmc,periodic-n0100-s01729,periodic,100,1729,power/2,0.00013337055503054564,8.040011291435734e-08,0.00013329106186048322,0.00013345691717819258,0.0001333440961917081,0.0001334060440307903,111 +dtmc,periodic-n0100-s01729,periodic,100,1729,return/bounded/k-10,9.149734355097236e-06,3.144100493491972e-08,9.12127728295031e-06,9.182537243059559e-06,9.137742422481854e-06,9.159425735640562e-06,140 +dtmc,periodic-n0100-s01729,periodic,100,1729,return/bounded/k-100,7.314512584322959e-05,9.484604470738525e-08,7.308212720967032e-05,7.329101560268707e-05,7.312009218960155e-05,7.317866453149523e-05,98 +dtmc,periodic-n0100-s01729,periodic,100,1729,stationary,0.0004229318736726919,3.556995732076915e-07,0.00042266821255907414,0.0004237143825270727,0.00042277775708388424,0.0004231747748675726,65 +dtmc,periodic-n0100-s01729,periodic,100,1729,structure/classes-cold,1.3662769202128837e-05,1.6825502110259934e-08,1.3648085357076847e-05,1.368475792005551e-05,1.3659547942908165e-05,1.3666806626133621e-05,132 +dtmc,periodic-n0100-s01729,periodic,100,1729,structure/classes-lifecycle,0.0005966797102488594,1.3066242203099536e-06,0.0005958353278692812,0.0005989068628039996,0.0005962142853864602,0.0005978763161358241,81 +dtmc,periodic-n0100-s01729,periodic,100,1729,structure/classes-warm/access,8.615809844581683e-09,9.837098946747726e-11,8.526263699000378e-09,1.0775860489999084e-08,8.557673287933314e-09,8.703224216201608e-09,309 +dtmc,periodic-n0100-s01729,periodic,100,1729,structure/classes-warm/consumed,4.888084158140495e-07,1.6731742997228867e-09,4.87617689658387e-07,4.977176070463395e-07,4.883185400338067e-07,4.897566657939883e-07,226 +dtmc,periodic-n0100-s01729,periodic,100,1729,structure/cyclic-classes-cold,2.7916133161929344e-05,1.5444656224161094e-07,2.7768774710881254e-05,2.8098224512567477e-05,2.7861164805168908e-05,2.798047224881456e-05,117 +dtmc,periodic-n0100-s01729,periodic,100,1729,structure/cyclic-classes-warm,8.691229095618883e-06,8.273196115485485e-09,8.685075017710477e-06,8.715099268061877e-06,8.68824335517393e-06,8.694868091075425e-06,167 +dtmc,periodic-n0100-s01729,periodic,100,1729,structure/irreducible-cold,6.557690749804561e-06,2.175364888100907e-08,6.538905659176458e-06,6.5831444756487e-06,6.553571438416839e-06,6.562906011548069e-06,147 +dtmc,periodic-n0100-s01729,periodic,100,1729,structure/irreducible-warm,9.629064435821465e-09,1.0735686003409225e-10,9.544424304604376e-09,1.176252413886408e-08,9.589632435203717e-09,9.710154730016709e-09,307 +dtmc,periodic-n0100-s01729,periodic,100,1729,structure/period-cold,1.608483174929507e-05,8.735766887497696e-08,1.599833466384717e-05,1.6177797153097937e-05,1.6056172385373537e-05,1.6109819038981908e-05,129 +dtmc,periodic-n0100-s01729,periodic,100,1729,structure/period-warm,1.1777882247276099e-08,1.1265487728124783e-10,1.1677922344160002e-08,1.435446291605875e-08,1.1737124262757618e-08,1.1827321236702242e-08,302 +dtmc,periodic-n0100-s01729,periodic,100,1729,visits/bounded-expectation/k-10,8.040465987645663e-06,1.8378845057808227e-08,8.022961038545516e-06,8.060941533920796e-06,8.034976197297824e-06,8.045515979879842e-06,143 +dtmc,periodic-n0100-s01729,periodic,100,1729,visits/bounded-expectation/k-100,6.762075508101229e-05,6.779959732941337e-08,6.756007762337866e-05,6.769636360095496e-05,6.75930592053114e-05,6.765403095138909e-05,99 +dtmc,periodic-n0100-s02718,periodic,100,2718,construction/public-consumed,0.0005855453540612243,1.0964903831204133e-06,0.000584076922118234,0.0005861851736982919,0.0005849311305412456,0.0005857404581367088,81 +dtmc,periodic-n0100-s02718,periodic,100,2718,evolution/k-10,1.0149392039540743e-05,1.3161267585517808e-08,1.0138935169609318e-05,1.0165125607300345e-05,1.0146353466115827e-05,1.015154129776317e-05,164 +dtmc,periodic-n0100-s02718,periodic,100,2718,evolution/k-100,9.517764565664783e-05,9.688134445890801e-08,9.508953106871591e-05,9.534390639910658e-05,9.51528998755632e-05,9.521596657577903e-05,118 +dtmc,periodic-n0100-s02718,periodic,100,2718,evolution/one-step,1.6160810844519654e-06,1.3647376926855933e-08,1.6062855012486882e-06,1.6532739252960754e-06,1.6108870909716676e-06,1.635122659862182e-06,201 +dtmc,periodic-n0100-s02718,periodic,100,2718,finite-time/n-step/k-10,8.8758700253298e-06,5.341130364215793e-08,8.832674663225307e-06,9.145406602328875e-06,8.863179751157653e-06,8.894890559430833e-06,140 +dtmc,periodic-n0100-s02718,periodic,100,2718,finite-time/n-step/k-100,7.020715129328892e-05,1.0416187324572158e-07,7.010727120879373e-05,7.032731678063424e-05,7.016136975738122e-05,7.02337743455751e-05,99 +dtmc,periodic-n0100-s02718,periodic,100,2718,finite-time/observation/k-10,0.000981018399749975,4.946332833530515e-06,0.00097776822806243,0.0009889150935729655,0.0009797078378419497,0.0009848023710893122,60 +dtmc,periodic-n0100-s02718,periodic,100,2718,finite-time/observation/k-100,0.008901291748770745,1.2262989529469512e-05,0.008896176519680193,0.00891639552448909,0.008898820313334,0.008913554738300215,31 +dtmc,periodic-n0100-s02718,periodic,100,2718,finite-time/step,8.52870190199089e-07,1.5887999362164355e-08,8.370329778412481e-07,8.689008000209647e-07,8.490789117698647e-07,8.568673354678519e-07,188 +dtmc,periodic-n0100-s02718,periodic,100,2718,hitting-probability/cold-all-states,0.0003011852553599772,3.067269435825799e-07,0.00030094018681362894,0.00030155729909893126,0.00030109624640317634,0.0003013989427761937,69 +dtmc,periodic-n0100-s02718,periodic,100,2718,hitting-probability/warm-lookup,2.4168443584078306e-08,5.396859970663901e-10,2.3640012710158252e-08,2.7521412776262773e-08,2.3765108098824177e-08,2.4260159232476088e-08,288 +dtmc,periodic-n0100-s02718,periodic,100,2718,hitting-time/cold-all-states,0.00029273366413286165,2.845212697542756e-07,0.0002924497998273913,0.00029301818540261593,0.0002925498934928328,0.00029284171901668447,69 +dtmc,periodic-n0100-s02718,periodic,100,2718,hitting-time/warm-lookup,2.4040742324982236e-08,1.624172136860315e-10,2.3913986872699247e-08,2.7192446994069525e-08,2.3997430624774514e-08,2.414121264323323e-08,288 +dtmc,periodic-n0100-s02718,periodic,100,2718,hitting/bounded/at-most/k-10,9.661283174577706e-06,4.517021571654928e-08,9.622002008654059e-06,9.715158519613232e-06,9.647718261203467e-06,9.672708738741747e-06,139 +dtmc,periodic-n0100-s02718,periodic,100,2718,hitting/bounded/at-most/k-100,3.9491183106414815e-05,5.2572312356494644e-08,3.9456702052686733e-05,3.958986426664636e-05,3.948391702655259e-05,3.952385824439781e-05,110 +dtmc,periodic-n0100-s02718,periodic,100,2718,hitting/bounded/exact/k-10,9.539200952846785e-06,5.5323759199934106e-08,9.501766748103756e-06,9.705799047052015e-06,9.522764303527571e-06,9.566597145749257e-06,139 +dtmc,periodic-n0100-s02718,periodic,100,2718,hitting/bounded/exact/k-100,3.920198798816012e-05,6.341608651845638e-08,3.915857836663165e-05,3.930671160428679e-05,3.918985668052402e-05,3.9234724500028903e-05,110 +dtmc,periodic-n0100-s02718,periodic,100,2718,hitting/bounded/greater-than/k-10,9.54200125609835e-06,4.174533601411928e-08,9.508801435522206e-06,9.777976083569229e-06,9.53596569907588e-06,9.553566728624173e-06,139 +dtmc,periodic-n0100-s02718,periodic,100,2718,hitting/bounded/greater-than/k-100,3.9180503032791116e-05,8.872899716385994e-08,3.9088994657500125e-05,3.926832551106468e-05,3.915600058051848e-05,3.919327123598619e-05,111 +dtmc,periodic-n0100-s02718,periodic,100,2718,power/10,0.0001655658620714756,2.1752597089728996e-07,0.0001653848742246614,0.00016581723847863258,0.00016552433644553268,0.0001656704544350787,107 +dtmc,periodic-n0100-s02718,periodic,100,2718,power/100,0.00020701711063106712,3.238717818949949e-07,0.0002067202223565824,0.0002073709079467113,0.00020685708873783386,0.0002071060975323182,102 +dtmc,periodic-n0100-s02718,periodic,100,2718,power/2,0.00013323786422085848,2.4045598286305146e-07,0.00013307677132119846,0.00013536573775733512,0.00013316631893783647,0.0001333315217314099,111 +dtmc,periodic-n0100-s02718,periodic,100,2718,return/bounded/k-10,9.211766083870886e-06,7.98512078742299e-08,9.152050552074797e-06,9.37108680690554e-06,9.19312809682673e-06,9.24537501608332e-06,137 +dtmc,periodic-n0100-s02718,periodic,100,2718,return/bounded/k-100,7.320372538325616e-05,2.4435321221923144e-07,7.299576226174533e-05,7.523258002612763e-05,7.303868337104056e-05,7.343375182244927e-05,98 +dtmc,periodic-n0100-s02718,periodic,100,2718,stationary,0.0004239022841239947,2.858216083206455e-07,0.0004236963347862818,0.00042437208959918534,0.0004238366581328017,0.0004240536224375853,66 +dtmc,periodic-n0100-s02718,periodic,100,2718,structure/classes-cold,1.3573716290574875e-05,2.0325285474235715e-08,1.3558172697200918e-05,1.3603217502203636e-05,1.3569923701654104e-05,1.3582319132348692e-05,132 +dtmc,periodic-n0100-s02718,periodic,100,2718,structure/classes-lifecycle,0.0005980978426889757,1.2366744318596974e-06,0.0005971966046438424,0.0006012758415044779,0.0005976739367248402,0.0005991577137527722,81 +dtmc,periodic-n0100-s02718,periodic,100,2718,structure/classes-warm/access,8.594294298354669e-09,7.957211840979852e-11,8.52979307856051e-09,1.089654102835847e-08,8.569425370363135e-09,8.723190022036501e-09,309 +dtmc,periodic-n0100-s02718,periodic,100,2718,structure/classes-warm/consumed,4.888099263972836e-07,1.6277470964019598e-09,4.875779637072412e-07,4.944547640858834e-07,4.88151955068074e-07,4.898013814284239e-07,226 +dtmc,periodic-n0100-s02718,periodic,100,2718,structure/cyclic-classes-cold,2.8001948066957993e-05,1.486458613191442e-07,2.7839259322111804e-05,2.811634788645722e-05,2.7951785963714908e-05,2.80273133465401e-05,117 +dtmc,periodic-n0100-s02718,periodic,100,2718,structure/cyclic-classes-warm,8.691823113065026e-06,6.743405848591577e-09,8.686233598619043e-06,8.70247046376765e-06,8.6909496751076e-06,8.693068819556487e-06,167 +dtmc,periodic-n0100-s02718,periodic,100,2718,structure/irreducible-cold,6.512774601943937e-06,1.9436940166815448e-08,6.497199669617942e-06,6.538176725012563e-06,6.508658124030812e-06,6.518689172093452e-06,147 +dtmc,periodic-n0100-s02718,periodic,100,2718,structure/irreducible-warm,9.616345818685728e-09,1.0066603440629116e-10,9.53183090597355e-09,1.1950825875998524e-08,9.571144684202372e-09,9.74537212468194e-09,307 +dtmc,periodic-n0100-s02718,periodic,100,2718,structure/period-cold,1.6081288294917176e-05,1.6618624764909318e-07,1.5927488794145376e-05,1.627642825264864e-05,1.603822870829727e-05,1.6147243694352512e-05,129 +dtmc,periodic-n0100-s02718,periodic,100,2718,structure/period-warm,1.1924693178745244e-08,2.591525272886262e-10,1.1687835173654993e-08,1.4499526057492226e-08,1.1780143781742957e-08,1.2034098949069847e-08,302 +dtmc,periodic-n0100-s02718,periodic,100,2718,visits/bounded-expectation/k-10,8.015038289713783e-06,4.057035483475003e-08,7.986133485564502e-06,8.140064010424822e-06,8.007843564312046e-06,8.034079713886753e-06,139 +dtmc,periodic-n0100-s02718,periodic,100,2718,visits/bounded-expectation/k-100,6.837752394522857e-05,6.818236543013138e-07,6.793739298116452e-05,7.09278101567179e-05,6.817326684510935e-05,6.93168597225147e-05,99 +dtmc,periodic-n0100-s31415,periodic,100,31415,construction/public-consumed,0.0005888898102342185,1.270597293107057e-06,0.0005878780923214637,0.0005909044540757528,0.0005884362249255028,0.0005894127025385387,81 +dtmc,periodic-n0100-s31415,periodic,100,31415,evolution/k-10,1.0188735185113154e-05,4.1007370864137464e-08,1.016979554117875e-05,1.0364012843255249e-05,1.0182363026587048e-05,1.0203652756393758e-05,163 +dtmc,periodic-n0100-s31415,periodic,100,31415,evolution/k-100,9.622249086731426e-05,6.19816868680847e-07,9.565955729936963e-05,9.778530857841686e-05,9.590862069985476e-05,9.651217269257584e-05,118 +dtmc,periodic-n0100-s31415,periodic,100,31415,evolution/one-step,1.6262400215252741e-06,1.4379874670843602e-08,1.6133984513174979e-06,1.650952077387068e-06,1.6229236994358726e-06,1.6311475644922918e-06,201 +dtmc,periodic-n0100-s31415,periodic,100,31415,finite-time/n-step/k-10,8.945174581579065e-06,5.665718050510345e-08,8.912556036977613e-06,9.166900315157807e-06,8.936424273997546e-06,8.961514219290957e-06,138 +dtmc,periodic-n0100-s31415,periodic,100,31415,finite-time/n-step/k-100,7.008349139784578e-05,9.734631396246117e-08,7.000807913110221e-05,7.022504341206709e-05,7.004629634320737e-05,7.013235372141935e-05,98 +dtmc,periodic-n0100-s31415,periodic,100,31415,finite-time/observation/k-10,0.0009795774042553403,6.72973023029043e-06,0.0009745413530750243,0.0009876541819331967,0.0009780689034470877,0.0009816653619054705,60 +dtmc,periodic-n0100-s31415,periodic,100,31415,finite-time/observation/k-100,0.008894691853908756,1.0848446081148516e-05,0.008884673093471856,0.008906728502673407,0.008887017711198755,0.008899014648341108,31 +dtmc,periodic-n0100-s31415,periodic,100,31415,finite-time/step,8.987865710098828e-07,3.3400963050323465e-08,8.758774017725064e-07,9.952321010275503e-07,8.849560150078364e-07,9.29219553952433e-07,185 +dtmc,periodic-n0100-s31415,periodic,100,31415,hitting-probability/cold-all-states,0.0003015167840203503,5.629313586433238e-07,0.0003011365408585536,0.0003022327509825118,0.0003013037954268707,0.00030172918195603415,69 +dtmc,periodic-n0100-s31415,periodic,100,31415,hitting-probability/warm-lookup,2.381370834004492e-08,1.9880426089790634e-10,2.362411917695835e-08,2.666432607875898e-08,2.3728256241889834e-08,2.3924697914304936e-08,288 +dtmc,periodic-n0100-s31415,periodic,100,31415,hitting-time/cold-all-states,0.0002930611712570758,9.121564825633919e-07,0.00029234079391409813,0.00029436413979691317,0.0002926498091894022,0.00029334716479449224,67 +dtmc,periodic-n0100-s31415,periodic,100,31415,hitting-time/warm-lookup,2.412451278107496e-08,2.3276753159986426e-10,2.3919584368962322e-08,2.784900037330026e-08,2.405644052853597e-08,2.4256082931459946e-08,288 +dtmc,periodic-n0100-s31415,periodic,100,31415,hitting/bounded/at-most/k-10,9.764647195452309e-06,8.064592523635032e-08,9.694382720993141e-06,9.954105535612835e-06,9.713135634995523e-06,9.781375410966575e-06,137 +dtmc,periodic-n0100-s31415,periodic,100,31415,hitting/bounded/at-most/k-100,3.958048897370565e-05,8.264517722030707e-08,3.952273472423676e-05,4.0083497879095376e-05,3.9556568792042666e-05,3.963460208530929e-05,109 +dtmc,periodic-n0100-s31415,periodic,100,31415,hitting/bounded/exact/k-10,9.672570740804076e-06,1.1038066568000852e-07,9.577551712649629e-06,9.894732306601691e-06,9.640245742238774e-06,9.726683665534745e-06,137 +dtmc,periodic-n0100-s31415,periodic,100,31415,hitting/bounded/exact/k-100,4.1408399046356174e-05,1.9088160002739964e-06,3.9605824079919915e-05,4.342961753233491e-05,4.074958562136553e-05,4.2107160958751876e-05,110 +dtmc,periodic-n0100-s31415,periodic,100,31415,hitting/bounded/greater-than/k-10,1.0727670505598171e-05,8.843686380663958e-07,1.002303166372462e-05,1.1979044920141176e-05,1.0481552551814428e-05,1.1140455151757248e-05,138 +dtmc,periodic-n0100-s31415,periodic,100,31415,hitting/bounded/greater-than/k-100,3.907554391910905e-05,4.358702497741444e-08,3.904047416010989e-05,3.9140635078484235e-05,3.9065885131509557e-05,3.9101561175330594e-05,110 +dtmc,periodic-n0100-s31415,periodic,100,31415,power/10,0.00017367787523518984,7.096466174922071e-06,0.00016712694764840232,0.0002170765373568215,0.00016797771544594476,0.00018460947804550053,106 +dtmc,periodic-n0100-s31415,periodic,100,31415,power/100,0.0002103448508584753,1.478332462349929e-06,0.00020923437477904372,0.00021679254757440451,0.0002099517044949938,0.00021176973677938804,101 +dtmc,periodic-n0100-s31415,periodic,100,31415,power/2,0.00013683230871884306,3.264698592948058e-06,0.00013399225901122446,0.0001439919808315328,0.00013542782801098533,0.00013908333321090876,109 +dtmc,periodic-n0100-s31415,periodic,100,31415,return/bounded/k-10,9.15866333157225e-06,3.962295989943503e-08,9.132823855733954e-06,9.448311070088935e-06,9.148726284899949e-06,9.169771249034556e-06,138 +dtmc,periodic-n0100-s31415,periodic,100,31415,return/bounded/k-100,7.29759719478516e-05,7.972992438896089e-08,7.291970746576369e-05,7.31162585261568e-05,7.295081807321615e-05,7.302141210318333e-05,98 +dtmc,periodic-n0100-s31415,periodic,100,31415,stationary,0.0004235570269027631,4.350037443608514e-07,0.0004232034558299347,0.0004243519919327809,0.00042338599127510353,0.00042370710062521156,66 +dtmc,periodic-n0100-s31415,periodic,100,31415,structure/classes-cold,1.3624917930708481e-05,3.2145231620284284e-08,1.3603452375278838e-05,1.378153401335386e-05,1.3615127240232791e-05,1.364064843643524e-05,129 +dtmc,periodic-n0100-s31415,periodic,100,31415,structure/classes-lifecycle,0.0006006277035757638,3.4821567268853403e-06,0.0005976822186597138,0.000608457841239381,0.0005982940845689761,0.0006024294117218587,80 +dtmc,periodic-n0100-s31415,periodic,100,31415,structure/classes-warm/access,8.735718619339313e-09,2.3627993604634186e-10,8.519650314219346e-09,1.1385538329979337e-08,8.640773039301533e-09,9.120360469393847e-09,308 +dtmc,periodic-n0100-s31415,periodic,100,31415,structure/classes-warm/consumed,4.925408042003364e-07,4.689834087401628e-09,4.887581871350326e-07,5.054980307999556e-07,4.91160409052446e-07,4.939114800296151e-07,226 +dtmc,periodic-n0100-s31415,periodic,100,31415,structure/cyclic-classes-cold,2.8017080118500294e-05,2.487494813091188e-07,2.7789025359236125e-05,2.829782078704596e-05,2.796168926386245e-05,2.808768157530757e-05,117 +dtmc,periodic-n0100-s31415,periodic,100,31415,structure/cyclic-classes-warm,8.685896150731983e-06,1.2450368393344995e-08,8.680384920512251e-06,8.742501342319498e-06,8.682667933716761e-06,8.69528984354026e-06,167 +dtmc,periodic-n0100-s31415,periodic,100,31415,structure/irreducible-cold,6.757238386139934e-06,1.1851569353761591e-07,6.6518745947311205e-06,6.926615568404663e-06,6.720748211338193e-06,6.799921568636337e-06,145 +dtmc,periodic-n0100-s31415,periodic,100,31415,structure/irreducible-warm,9.82854763249782e-09,2.964584446928236e-10,9.548834304953307e-09,1.2221878851623716e-08,9.733480570039792e-09,9.971284340227874e-09,307 +dtmc,periodic-n0100-s31415,periodic,100,31415,structure/period-cold,1.6231430749841023e-05,1.6286146868513376e-07,1.608674464807388e-05,1.6494878389708258e-05,1.6178756477737812e-05,1.6270736906383382e-05,129 +dtmc,periodic-n0100-s31415,periodic,100,31415,structure/period-warm,1.2240605162825845e-08,5.507096977893891e-10,1.1842132038904807e-08,1.48408906790172e-08,1.2044188113083242e-08,1.2429783005878304e-08,302 +dtmc,periodic-n0100-s31415,periodic,100,31415,visits/bounded-expectation/k-10,8.102503555676975e-06,6.128475322668106e-08,8.05989619023597e-06,8.258050494558717e-06,8.083396824076772e-06,8.132354236580018e-06,143 +dtmc,periodic-n0100-s31415,periodic,100,31415,visits/bounded-expectation/k-100,6.762235440148771e-05,6.407355815052872e-08,6.757656521597326e-05,6.772405079876383e-05,6.761391142817637e-05,6.764201846967027e-05,97 +dtmc,periodic-n0250-s01729,periodic,250,1729,construction/public-consumed,0.005389202286356262,0.00023627173227612833,0.0052346364698558755,0.005892967262687827,0.005265697928345097,0.005672110294279478,39 +dtmc,periodic-n0250-s01729,periodic,250,1729,evolution/k-10,7.584556877080123e-05,1.1679346476858361e-07,7.576083522603831e-05,7.611300155667522e-05,7.579869571708164e-05,7.590372791135011e-05,122 +dtmc,periodic-n0250-s01729,periodic,250,1729,evolution/k-100,0.0007433910385173548,3.9946115049121394e-07,0.0007431299284467152,0.0007449051497488931,0.0007432250000420027,0.0007436370804544198,76 +dtmc,periodic-n0250-s01729,periodic,250,1729,evolution/one-step,9.165306619618934e-06,1.1719717745417625e-07,9.051076065184545e-06,9.325980211123972e-06,9.069065602255086e-06,9.239235960909824e-06,166 +dtmc,periodic-n0250-s01729,periodic,250,1729,hitting-probability/cold-all-states,0.0016821584024000913,3.415405323418594e-06,0.0016799384738197145,0.0016876540007965209,0.0016800117155071348,0.0016852276107082226,33 +dtmc,periodic-n0250-s01729,periodic,250,1729,hitting-probability/warm-lookup,2.725776745531165e-08,2.941976854359117e-09,2.5380488485220014e-08,3.716024431664158e-08,2.686524742393065e-08,2.7893315043307856e-08,286 +dtmc,periodic-n0250-s01729,periodic,250,1729,hitting-time/cold-all-states,0.001699436979981277,3.0118833363223358e-05,0.0016799676362001272,0.0018726359910942846,0.0016814011983418216,0.0017722941222874558,34 +dtmc,periodic-n0250-s01729,periodic,250,1729,hitting-time/warm-lookup,2.4224491658550468e-08,3.460811173222122e-10,2.3915229723026374e-08,2.843331030757823e-08,2.4098189781583544e-08,2.462503305585125e-08,288 +dtmc,periodic-n0250-s01729,periodic,250,1729,power/10,0.00113926003219372,1.4357281474815025e-05,0.0011231171438427475,0.0011514265788826752,0.0011303469915359388,0.0011432657598709952,68 +dtmc,periodic-n0250-s01729,periodic,250,1729,power/100,0.0015990853412643589,1.3370396654688874e-05,0.0015861517692533963,0.0016142754052929202,0.001592740573687479,0.0016082949844142694,62 +dtmc,periodic-n0250-s01729,periodic,250,1729,power/2,0.0008153987853780298,1.5805035034255365e-05,0.0007974388038703529,0.0008220056629368328,0.0008083437501530473,0.0008183605624997819,75 +dtmc,periodic-n0250-s01729,periodic,250,1729,stationary,0.006344893312416389,6.309683158178814e-06,0.006342593942959369,0.006353755732804226,0.006343455078492228,0.0063512029955745675,27 +dtmc,periodic-n0250-s01729,periodic,250,1729,structure/classes-cold,3.395284147700295e-05,1.9943236482652737e-07,3.3790210370668476e-05,3.415811808755714e-05,3.391779770451625e-05,3.4013550484094304e-05,113 +dtmc,periodic-n0250-s01729,periodic,250,1729,structure/classes-lifecycle,0.00526525055082809,2.175119612714228e-05,0.005232936450192937,0.0052806339947644365,0.005247408280166467,0.005272907274775207,40 +dtmc,periodic-n0250-s01729,periodic,250,1729,structure/classes-warm/access,8.783113580708212e-09,2.681347728088439e-10,8.53121448485194e-09,1.1393164337884324e-08,8.620690366504706e-09,8.830993503363714e-09,309 +dtmc,periodic-n0250-s01729,periodic,250,1729,structure/classes-warm/consumed,1.2563448745328084e-06,3.4413378788243858e-09,1.2532680899847149e-06,1.2699763163153715e-06,1.2552496941736925e-06,1.257703122165468e-06,207 +dtmc,periodic-n0250-s01729,periodic,250,1729,structure/cyclic-classes-cold,8.835411247417547e-05,4.064530371111511e-07,8.80849839779036e-05,8.892640693231043e-05,8.823949473135359e-05,8.856178747668889e-05,94 +dtmc,periodic-n0250-s01729,periodic,250,1729,structure/cyclic-classes-warm,2.170339428742719e-05,2.2605217998788405e-08,2.1682085861012775e-05,2.172739127984156e-05,2.1699332701980298e-05,2.170757098899301e-05,148 +dtmc,periodic-n0250-s01729,periodic,250,1729,structure/irreducible-cold,1.6196118580406886e-05,1.352969198520488e-07,1.6071621622383094e-05,1.636998850634286e-05,1.613891338163742e-05,1.626244803195108e-05,128 +dtmc,periodic-n0250-s01729,periodic,250,1729,structure/irreducible-warm,9.678413728498955e-09,1.6815152698617248e-10,9.528532196040388e-09,1.1825863495528421e-08,9.638598058194267e-09,9.785113874263471e-09,307 +dtmc,periodic-n0250-s01729,periodic,250,1729,structure/period-cold,5.2352057537063956e-05,5.021778905816424e-07,5.188943699370915e-05,5.290429900459787e-05,5.2178768194554484e-05,5.251273312001624e-05,105 +dtmc,periodic-n0250-s01729,periodic,250,1729,structure/period-warm,1.1835756252906256e-08,1.543744415080434e-10,1.1691048318139885e-08,1.4290568312523248e-08,1.1770520142741437e-08,1.1928808321308966e-08,302 +dtmc,periodic-n0250-s02718,periodic,250,2718,construction/public-consumed,0.0051627638837089766,3.690969634113743e-05,0.005117793595369828,0.005197776339887891,0.0051383290116548425,0.0051865822325448015,40 +dtmc,periodic-n0250-s02718,periodic,250,2718,evolution/k-10,7.61850003202978e-05,4.830451271394879e-07,7.577410674055407e-05,7.796658227563723e-05,7.595315390764818e-05,7.65347479803798e-05,122 +dtmc,periodic-n0250-s02718,periodic,250,2718,evolution/k-100,0.0007426739988766392,6.431728438295679e-07,0.0007422016126163785,0.0007437749998643994,0.0007424001221612579,0.0007430202286091767,77 +dtmc,periodic-n0250-s02718,periodic,250,2718,evolution/one-step,9.052153605767234e-06,1.3166270727708849e-08,9.041497059441887e-06,9.115914118547242e-06,9.046888105236172e-06,9.057812712853775e-06,166 +dtmc,periodic-n0250-s02718,periodic,250,2718,hitting-probability/cold-all-states,0.0016877777522798473,5.658443357485022e-06,0.0016827489876289434,0.0016936086376517778,0.001685547967843542,0.0016924692199272275,34 +dtmc,periodic-n0250-s02718,periodic,250,2718,hitting-probability/warm-lookup,2.3811164354181672e-08,2.0538511778952114e-10,2.362507153480611e-08,2.7160049872222905e-08,2.3739084954335295e-08,2.3939358179693045e-08,288 +dtmc,periodic-n0250-s02718,periodic,250,2718,hitting-time/cold-all-states,0.0016694713561475802,4.98957961099218e-06,0.0016664880824560225,0.0016770902056436094,0.0016675440009053359,0.001673976149443964,34 +dtmc,periodic-n0250-s02718,periodic,250,2718,hitting-time/warm-lookup,2.409426682341725e-08,2.1642696836581308e-10,2.3898722232108225e-08,2.7632513997872714e-08,2.4010853981116554e-08,2.4299433133638943e-08,288 +dtmc,periodic-n0250-s02718,periodic,250,2718,power/10,0.0011549375000565003,3.726010050048088e-05,0.0011202194339906175,0.0012165073524503147,0.0011389006939747015,0.0011646906248643063,65 +dtmc,periodic-n0250-s02718,periodic,250,2718,power/100,0.0016094173668534495,1.6792367802866354e-05,0.0015939090914219957,0.001627024703473715,0.0016002135616872692,0.001619883000295466,61 +dtmc,periodic-n0250-s02718,periodic,250,2718,power/2,0.0008145929487966233,1.4310361771656486e-05,0.0007992893329679242,0.0008218206555691641,0.0008077394959400408,0.0008181929867867822,75 +dtmc,periodic-n0250-s02718,periodic,250,2718,stationary,0.00637669274870766,2.6515272655801975e-05,0.0063542431652985265,0.006437163139101661,0.006359154331644264,0.006406792992008074,26 +dtmc,periodic-n0250-s02718,periodic,250,2718,structure/classes-cold,3.4290105148243437e-05,7.345590213828445e-07,3.3711451223193924e-05,3.5767730217567285e-05,3.395081148482859e-05,3.4779876459373414e-05,112 +dtmc,periodic-n0250-s02718,periodic,250,2718,structure/classes-lifecycle,0.005256186077696673,4.610220824243557e-05,0.005198566480880349,0.005286305166557053,0.005224766203866501,0.005269344269186991,40 +dtmc,periodic-n0250-s02718,periodic,250,2718,structure/classes-warm/access,8.817706554004982e-09,3.1124016396855175e-10,8.54953534336764e-09,1.176989833854501e-08,8.71010055550209e-09,8.925855619902489e-09,308 +dtmc,periodic-n0250-s02718,periodic,250,2718,structure/classes-warm/consumed,1.2585614748566238e-06,7.240744724975185e-09,1.2534528616957488e-06,1.272590291970503e-06,1.2571116606891614e-06,1.261288918700401e-06,206 +dtmc,periodic-n0250-s02718,periodic,250,2718,structure/cyclic-classes-cold,9.118898457888028e-05,1.7160159687361077e-06,8.947296861014417e-05,9.270059268197251e-05,9.071438745152028e-05,9.195603100427736e-05,93 +dtmc,periodic-n0250-s02718,periodic,250,2718,structure/cyclic-classes-warm,2.1776562136602047e-05,7.400664946946074e-08,2.1726237476139537e-05,2.206250129448664e-05,2.1756780246332255e-05,2.180539692663274e-05,146 +dtmc,periodic-n0250-s02718,periodic,250,2718,structure/irreducible-cold,1.7159637024764982e-05,8.779570005713574e-07,1.6367084969288842e-05,1.832238257429273e-05,1.690030372611673e-05,1.73842099023911e-05,127 +dtmc,periodic-n0250-s02718,periodic,250,2718,structure/irreducible-warm,9.759903068128979e-09,2.3661511839162105e-10,9.574527948899415e-09,1.2108114706781023e-08,9.701050868071606e-09,1.0000518168026624e-08,306 +dtmc,periodic-n0250-s02718,periodic,250,2718,structure/period-cold,5.399307908793051e-05,1.348863737007188e-06,5.302535525212685e-05,5.6286001525609564e-05,5.359568003669402e-05,5.5060529636468e-05,102 +dtmc,periodic-n0250-s02718,periodic,250,2718,structure/period-warm,1.2183223285358709e-08,3.4603110242485953e-10,1.1896311945164106e-08,1.5286165829066457e-08,1.2036407670992316e-08,1.2349207559957894e-08,302 +dtmc,periodic-n0250-s31415,periodic,250,31415,construction/public-consumed,0.005185712188004369,2.225783033842684e-05,0.005149570823778049,0.005198438766088297,0.005164596154345087,0.005195217338041402,40 +dtmc,periodic-n0250-s31415,periodic,250,31415,evolution/k-10,7.752654246793273e-05,1.414596962761318e-06,7.616433321505697e-05,7.912138998190958e-05,7.740718137938529e-05,7.790538775760283e-05,122 +dtmc,periodic-n0250-s31415,periodic,250,31415,evolution/k-100,0.0007439496495848112,7.695515724354769e-07,0.0007432522505184063,0.000745068228217324,0.0007437178367508072,0.0007442960158994784,76 +dtmc,periodic-n0250-s31415,periodic,250,31415,evolution/one-step,9.06957039029175e-06,1.702775208686226e-08,9.058319280143753e-06,9.113137654209397e-06,9.062925913870097e-06,9.074540292094816e-06,166 +dtmc,periodic-n0250-s31415,periodic,250,31415,hitting-probability/cold-all-states,0.0016985833297237856,9.952085545390029e-06,0.0016911960396299365,0.0017124918146835528,0.0016926249673512453,0.0017085428294699844,34 +dtmc,periodic-n0250-s31415,periodic,250,31415,hitting-probability/warm-lookup,2.397963726529141e-08,3.6351603692794027e-10,2.367393850873064e-08,2.7356202253698625e-08,2.385150948195224e-08,2.4133142819976366e-08,287 +dtmc,periodic-n0250-s31415,periodic,250,31415,hitting-time/cold-all-states,0.001691093502449803,1.2102712538431958e-05,0.0016797724719463775,0.0017055711211772483,0.0016826894504695454,0.001697753580325904,34 +dtmc,periodic-n0250-s31415,periodic,250,31415,hitting-time/warm-lookup,2.42159824738554e-08,3.289673543400888e-10,2.3934445488974314e-08,2.749575987064208e-08,2.4103141254020366e-08,2.4440550991044145e-08,288 +dtmc,periodic-n0250-s31415,periodic,250,31415,power/10,0.0011434569516460017,1.5544802405273233e-05,0.0011232572500635537,0.0011542746568488156,0.0011293833006015992,0.001147493227128709,68 +dtmc,periodic-n0250-s31415,periodic,250,31415,power/100,0.001603668317408807,2.2693699064843184e-05,0.0015792295668299113,0.001620930635660016,0.00158723418617565,0.0016129669652905755,60 +dtmc,periodic-n0250-s31415,periodic,250,31415,power/2,0.000815390112620662,1.3119729393362462e-05,0.0007976052006763153,0.0008218471913160911,0.000804724998306483,0.0008189769371327762,75 +dtmc,periodic-n0250-s31415,periodic,250,31415,stationary,0.006369793291014503,1.6681609098589435e-05,0.006354072391094751,0.0063880378865854796,0.006356387294705629,0.006381366848169516,26 +dtmc,periodic-n0250-s31415,periodic,250,31415,structure/classes-cold,3.4559121796723496e-05,3.2268194342999345e-07,3.427851552260108e-05,3.502618998820643e-05,3.447042898434804e-05,3.4673503250814974e-05,112 +dtmc,periodic-n0250-s31415,periodic,250,31415,structure/classes-lifecycle,0.005294092164936768,8.332478315517707e-05,0.005228291544929226,0.005409473032045261,0.00524350675990278,0.005333741777576506,38 +dtmc,periodic-n0250-s31415,periodic,250,31415,structure/classes-warm/access,8.599549207998358e-09,9.223299144256999e-11,8.525682512325689e-09,1.0814220018562723e-08,8.582960701629632e-09,8.691782199440928e-09,309 +dtmc,periodic-n0250-s31415,periodic,250,31415,structure/classes-warm/consumed,1.25553899453467e-06,3.4037025443836543e-09,1.2532284142075867e-06,1.2751958047226374e-06,1.2547317753028314e-06,1.2581594095467677e-06,206 +dtmc,periodic-n0250-s31415,periodic,250,31415,structure/cyclic-classes-cold,9.238185784091035e-05,2.1746841917370623e-06,9.108299945578463e-05,9.867895841261967e-05,9.191534989905708e-05,9.418436402484077e-05,92 +dtmc,periodic-n0250-s31415,periodic,250,31415,structure/cyclic-classes-warm,2.17617993397014e-05,8.203511540517548e-08,2.169548552046763e-05,2.1910607259433472e-05,2.1736783495687067e-05,2.1805018079657182e-05,148 +dtmc,periodic-n0250-s31415,periodic,250,31415,structure/irreducible-cold,1.7305500756966185e-05,8.961963488714401e-07,1.647715507715475e-05,1.853567821559573e-05,1.6914946367125037e-05,1.7620325066942582e-05,126 +dtmc,periodic-n0250-s31415,periodic,250,31415,structure/irreducible-warm,1.0211373989293275e-08,5.969510280104502e-10,9.707508319386836e-09,1.3017372553935648e-08,1.0072009277604295e-08,1.0318819209653239e-08,306 +dtmc,periodic-n0250-s31415,periodic,250,31415,structure/period-cold,5.327946735354068e-05,1.3810492090392643e-06,5.225935003991068e-05,5.8550779201085586e-05,5.29025485845067e-05,5.386792988961423e-05,104 +dtmc,periodic-n0250-s31415,periodic,250,31415,structure/period-warm,1.1915304250594415e-08,2.49245213535569e-10,1.1688660544094926e-08,1.511272315398386e-08,1.1812240013720867e-08,1.2028508846942298e-08,300 +dtmc,periodic-n0500-s01729,periodic,500,1729,construction/public-consumed,0.030041765625355765,0.0006346892914734781,0.029593749998769323,0.03364481250173412,0.029593749998769323,0.03364481250173412,17 +dtmc,periodic-n0500-s01729,periodic,500,1729,evolution/k-10,0.00029790634495428705,4.5274521053413836e-07,0.0002972358341359503,0.0002981087438948225,0.0002975481069630145,0.0002979967106703522,95 +dtmc,periodic-n0500-s01729,periodic,500,1729,evolution/k-100,0.0029417548721226844,8.935776239138351e-07,0.0029412501865711724,0.0029428361868377596,0.0029415403490900874,0.00294219815306234,50 +dtmc,periodic-n0500-s01729,periodic,500,1729,evolution/one-step,3.286541195885919e-05,5.8813944333575916e-08,3.282745547574551e-05,3.297700208819268e-05,3.2851182976709747e-05,3.289054880244188e-05,140 +dtmc,periodic-n0500-s01729,periodic,500,1729,hitting-probability/cold-all-states,0.012005299999145791,0.00010325116939687538,0.01190579137619352,0.012490067458622014,0.01190579137619352,0.012490067458622014,13 +dtmc,periodic-n0500-s01729,periodic,500,1729,hitting-probability/warm-lookup,2.413996522308096e-08,5.004055127214023e-10,2.3716322240437398e-08,2.810702559691614e-08,2.395592753682398e-08,2.4368223974035177e-08,287 +dtmc,periodic-n0500-s01729,periodic,500,1729,hitting-time/cold-all-states,0.012069478375321654,0.00023399227661901126,0.011961766966123832,0.012643330548838762,0.011963039857619151,0.012568717234119373,14 +dtmc,periodic-n0500-s01729,periodic,500,1729,hitting-time/warm-lookup,2.505268343220231e-08,1.119461963661701e-09,2.4038930517741053e-08,2.8756907816792155e-08,2.483878170360135e-08,2.5326800015237595e-08,287 +dtmc,periodic-n0500-s01729,periodic,500,1729,power/10,0.00667876546050186,9.344224628274203e-05,0.006585697321684815,0.006769515656287695,0.006625472221963314,0.006734463283464877,36 +dtmc,periodic-n0500-s01729,periodic,500,1729,power/100,0.011127390905693616,0.0001012599414458408,0.010995715908145277,0.01122093117421331,0.011086261132732034,0.011205257353140041,29 +dtmc,periodic-n0500-s01729,periodic,500,1729,power/2,0.004183684506524119,6.741792557664978e-05,0.0041173739470347455,0.004239801323259977,0.004146236320648864,0.0042147782254433365,44 +dtmc,periodic-n0500-s01729,periodic,500,1729,stationary,0.05174507302508573,0.00033455386806703277,0.05152724093204597,0.05229090458791082,0.051470393441074215,0.05286628817945409,10 +dtmc,periodic-n0500-s01729,periodic,500,1729,structure/classes-cold,7.349059912087214e-05,3.425478597261704e-07,7.321316140281264e-05,7.407729600264312e-05,7.33377227450733e-05,7.361946151673144e-05,98 +dtmc,periodic-n0500-s01729,periodic,500,1729,structure/classes-lifecycle,0.029528270875744056,0.00015787927404744412,0.029375354200601576,0.02973063422056536,0.029375354200601576,0.02973063422056536,17 +dtmc,periodic-n0500-s01729,periodic,500,1729,structure/classes-warm/access,8.680622095905087e-09,1.8278212185394708e-10,8.510807925277929e-09,1.0918670176831355e-08,8.627510857926203e-09,8.752351516910691e-09,309 +dtmc,periodic-n0500-s01729,periodic,500,1729,structure/classes-warm/consumed,2.532108262699909e-06,7.047869711091782e-09,2.526374877989016e-06,2.5453800238513696e-06,2.5305738215217056e-06,2.533814337435357e-06,192 +dtmc,periodic-n0500-s01729,periodic,500,1729,structure/cyclic-classes-cold,0.00019482045345717953,2.3405230632180993e-06,0.00019235522772201844,0.0001970355590822658,0.0001935754971782444,0.00019528466752187038,77 +dtmc,periodic-n0500-s01729,periodic,500,1729,structure/cyclic-classes-warm,4.384901273480959e-05,3.1280887572090625e-07,4.361578264400449e-05,4.502728448558918e-05,4.370218118841779e-05,4.4165588314079224e-05,132 +dtmc,periodic-n0500-s01729,periodic,500,1729,structure/irreducible-cold,3.791217958288533e-05,3.4693502197636207e-07,3.7600219831431e-05,3.8494508110888665e-05,3.774659534089961e-05,3.804166206262178e-05,111 +dtmc,periodic-n0500-s01729,periodic,500,1729,structure/irreducible-warm,1.0024535227961962e-08,4.985640606939672e-10,9.536715265947748e-09,1.2283636829204345e-08,9.879101786644072e-09,1.0160264706270341e-08,307 +dtmc,periodic-n0500-s01729,periodic,500,1729,structure/period-cold,0.00012474990494194485,1.2300048693620344e-06,0.0001237419154592829,0.0001266040198970586,0.00012417519465088845,0.00012550636655556,85 +dtmc,periodic-n0500-s01729,periodic,500,1729,structure/period-warm,1.2070156300359241e-08,4.0151904089109514e-10,1.176561543186121e-08,1.4730189094137406e-08,1.1944878152012041e-08,1.2207236115042335e-08,302 +dtmc,periodic-n0500-s02718,periodic,500,2718,construction/public-consumed,0.02889593321326954,0.00019557735764205372,0.028703621500729543,0.02908268378658769,0.028705743002016483,0.02907271285844867,18 +dtmc,periodic-n0500-s02718,periodic,500,2718,evolution/k-10,0.0002981275615568917,4.510669816082478e-07,0.0002974845043372795,0.00029836324523810196,0.0002978571449472968,0.0002982713358942419,95 +dtmc,periodic-n0500-s02718,periodic,500,2718,evolution/k-100,0.002950064194608793,3.156497451131538e-06,0.002947974507103362,0.002957124959114784,0.0029487358674779867,0.0029520239080373253,50 +dtmc,periodic-n0500-s02718,periodic,500,2718,evolution/one-step,3.271127516804847e-05,5.560958954743813e-08,3.266550670784173e-05,3.280758496848732e-05,3.2698586094408985e-05,3.2729715755225046e-05,140 +dtmc,periodic-n0500-s02718,periodic,500,2718,hitting-probability/cold-all-states,0.011473476996697072,3.593959328201078e-05,0.011452412660825455,0.01153660413013616,0.011454596155090258,0.011563791670293236,15 +dtmc,periodic-n0500-s02718,periodic,500,2718,hitting-probability/warm-lookup,2.3862065230042568e-08,2.700809690976038e-10,2.3608148700475392e-08,2.8025453336285765e-08,2.3766168083737998e-08,2.4017659828673155e-08,288 +dtmc,periodic-n0500-s02718,periodic,500,2718,hitting-time/cold-all-states,0.011441045331594069,2.8621296223718673e-05,0.011414016907136622,0.011491181456741677,0.011415566597133876,0.011469666627817787,15 +dtmc,periodic-n0500-s02718,periodic,500,2718,hitting-time/warm-lookup,2.4127308157023068e-08,2.6803420948524084e-10,2.387581485136301e-08,2.7267698577226516e-08,2.4022965924960175e-08,2.4245067102766383e-08,288 +dtmc,periodic-n0500-s02718,periodic,500,2718,power/10,0.006654747048918169,8.546333618031712e-05,0.0065644360677795605,0.0067294781519986035,0.006583342591680035,0.006698056175082456,36 +dtmc,periodic-n0500-s02718,periodic,500,2718,power/100,0.011116962500091176,0.00016001950019639555,0.010998305583295101,0.011372115500059655,0.011025217555773755,0.011201838624401717,29 +dtmc,periodic-n0500-s02718,periodic,500,2718,power/2,0.004145980117784116,6.33379232687979e-05,0.004084152347355417,0.004202238278824608,0.004111867808733604,0.0041743942390703274,44 +dtmc,periodic-n0500-s02718,periodic,500,2718,stationary,0.0514845210830875,9.41005872889672e-05,0.05133871723955963,0.051559206804631684,0.05133568320889026,0.051562156240834156,10 +dtmc,periodic-n0500-s02718,periodic,500,2718,structure/classes-cold,7.4025879064226e-05,4.156922060676271e-07,7.378102606450509e-05,7.517663287904321e-05,7.396041979998219e-05,7.444393674116098e-05,96 +dtmc,periodic-n0500-s02718,periodic,500,2718,structure/classes-lifecycle,0.02899034514224955,0.0003204465236714381,0.0286571319156792,0.029271562500590726,0.0286571319156792,0.029271562500590726,17 +dtmc,periodic-n0500-s02718,periodic,500,2718,structure/classes-warm/access,9.286897212312434e-09,5.353872302721201e-10,9.019523224838931e-09,1.1914013156862247e-08,9.211599034601468e-09,9.399163029396764e-09,308 +dtmc,periodic-n0500-s02718,periodic,500,2718,structure/classes-warm/consumed,2.5361183028167526e-06,6.579668724107089e-09,2.5302303555331387e-06,2.5505090630594227e-06,2.5336096284097225e-06,2.539058031977492e-06,192 +dtmc,periodic-n0500-s02718,periodic,500,2718,structure/cyclic-classes-cold,0.00019265605576410582,1.0163766200722515e-06,0.00019165628736138893,0.0001936664288321579,0.00019227141077129343,0.00019307753065788216,78 +dtmc,periodic-n0500-s02718,periodic,500,2718,structure/cyclic-classes-warm,4.3660224267704687e-05,4.8594443123370465e-08,4.360504449676082e-05,4.3699512995048015e-05,4.3647755491910985e-05,4.367045370269228e-05,134 +dtmc,periodic-n0500-s02718,periodic,500,2718,structure/irreducible-cold,3.784929338453548e-05,3.6646824713047136e-07,3.758296125228496e-05,3.837362088042459e-05,3.771907736665068e-05,3.799986110867134e-05,110 +dtmc,periodic-n0500-s02718,periodic,500,2718,structure/irreducible-warm,9.7245623764386e-09,2.225363685449923e-10,9.5189088043288e-09,1.2046241801478488e-08,9.661770001120636e-09,9.776329540623795e-09,307 +dtmc,periodic-n0500-s02718,periodic,500,2718,structure/period-cold,0.00012488572734657713,8.133118346769028e-07,0.00012408837553338782,0.00012570244190995367,0.0001245494286244725,0.00012522347242338583,87 +dtmc,periodic-n0500-s02718,periodic,500,2718,structure/period-warm,1.193038254371571e-08,2.690034075047773e-10,1.1679290954911942e-08,1.4568288499933577e-08,1.1844842456014842e-08,1.2039927677067571e-08,302 +dtmc,periodic-n0500-s31415,periodic,500,31415,construction/public-consumed,0.029599141667131335,0.0001954413135536008,0.029256972338771448,0.02975716675427975,0.029256972338771448,0.02975716675427975,17 +dtmc,periodic-n0500-s31415,periodic,500,31415,evolution/k-10,0.00029801595720779545,6.293759435597405e-07,0.0002973405986047124,0.0002985524086672637,0.0002978840577956019,0.00029813170397250066,95 +dtmc,periodic-n0500-s31415,periodic,500,31415,evolution/k-100,0.0029462216597553855,1.5187833923846483e-06,0.0029447373161881267,0.0029477155007953115,0.002945419968224116,0.002946702285303867,50 +dtmc,periodic-n0500-s31415,periodic,500,31415,evolution/one-step,3.278044086526103e-05,3.281090152814831e-08,3.274900467807395e-05,3.281855559464118e-05,3.277407972729372e-05,3.278924551913016e-05,140 +dtmc,periodic-n0500-s31415,periodic,500,31415,hitting-probability/cold-all-states,0.011822790522678083,6.618783399145196e-05,0.01176845952437501,0.011905517094419338,0.011767573764350696,0.01189979443734046,14 +dtmc,periodic-n0500-s31415,periodic,500,31415,hitting-probability/warm-lookup,2.3834079691344085e-08,2.3548516286550246e-10,2.3616341787788628e-08,2.707155954839846e-08,2.3713462807169767e-08,2.4004942503328332e-08,288 +dtmc,periodic-n0500-s31415,periodic,500,31415,hitting-time/cold-all-states,0.011770097160964117,6.327601983348308e-05,0.011705635033669733,0.011815718688012566,0.011706762642057443,0.011817572832417985,14 +dtmc,periodic-n0500-s31415,periodic,500,31415,hitting-time/warm-lookup,2.4053227643402557e-08,1.8467241506524806e-10,2.388954649117828e-08,2.7508972871209778e-08,2.3980923377520315e-08,2.420335972399858e-08,288 +dtmc,periodic-n0500-s31415,periodic,500,31415,power/10,0.006700837562415732,0.0001391721322978861,0.006571805233228717,0.006828562062525267,0.006618643117188993,0.0067907312506577,36 +dtmc,periodic-n0500-s31415,periodic,500,31415,power/100,0.01110628699987299,8.631306243640086e-05,0.011035293359309434,0.011195680669819316,0.01106779166633108,0.011169748385257732,29 +dtmc,periodic-n0500-s31415,periodic,500,31415,power/2,0.004200454985125578,7.680761446531405e-05,0.004124063667000478,0.004273240433854991,0.004159722241721201,0.004243572935214123,44 +dtmc,periodic-n0500-s31415,periodic,500,31415,stationary,0.05136868056215462,2.1770765687548904e-05,0.05135593924993979,0.05139103816154169,0.051351090334113295,0.051391909820570916,10 +dtmc,periodic-n0500-s31415,periodic,500,31415,structure/classes-cold,7.444447687596486e-05,1.4867282750383239e-06,7.331263068841682e-05,7.787135452089257e-05,7.359570303958827e-05,7.579003086862697e-05,96 +dtmc,periodic-n0500-s31415,periodic,500,31415,structure/classes-lifecycle,0.02961221428787602,0.0002206830374364352,0.029391531250439584,0.029734191700117662,0.029391531250439584,0.029734191700117662,17 +dtmc,periodic-n0500-s31415,periodic,500,31415,structure/classes-warm/access,8.806619807984556e-09,2.7897963103119976e-10,8.563447679030737e-09,1.1076473095686332e-08,8.687363265775118e-09,8.910901309682592e-09,309 +dtmc,periodic-n0500-s31415,periodic,500,31415,structure/classes-warm/consumed,2.5570927256787265e-06,2.3593957254411503e-08,2.539577528100592e-06,2.616460349055637e-06,2.5478969376111766e-06,2.566275127066437e-06,191 +dtmc,periodic-n0500-s31415,periodic,500,31415,structure/cyclic-classes-cold,0.0001921060359861652,5.71230249076795e-07,0.00019161480348402064,0.0001930662540125718,0.00019193965721221523,0.00019245722464107803,78 +dtmc,periodic-n0500-s31415,periodic,500,31415,structure/cyclic-classes-warm,4.366501131394507e-05,3.7880871150801354e-08,4.362120987410407e-05,4.370158338585253e-05,4.3651340472539464e-05,4.3673584900607555e-05,134 +dtmc,periodic-n0500-s31415,periodic,500,31415,structure/irreducible-cold,4.0241498605940827e-05,1.566080698694734e-06,3.896380506127819e-05,4.2993574215170855e-05,3.97123576251769e-05,4.0666217742278716e-05,109 +dtmc,periodic-n0500-s31415,periodic,500,31415,structure/irreducible-warm,9.795891912336129e-09,2.5813193667062593e-10,9.615780161570682e-09,1.2512340377965062e-08,9.751329637980109e-09,9.895226510928781e-09,306 +dtmc,periodic-n0500-s31415,periodic,500,31415,structure/period-cold,0.00012620928308940742,1.8628473017665264e-06,0.00012475391201814448,0.0001298492550582474,0.00012571823742565892,0.00012800037048118948,87 +dtmc,periodic-n0500-s31415,periodic,500,31415,structure/period-warm,1.1940917893306196e-08,2.7868048865368624e-10,1.1674889904414248e-08,1.4509252448450422e-08,1.1863674068083616e-08,1.2068087059108676e-08,302 +dtmc,periodic-n1000-s01729,periodic,1000,1729,construction/public-consumed,0.12937975700212218,0.004000536629973794,0.12541979588734517,0.1326775702129453,0.12525215067746884,0.13358053125193692,8 +dtmc,periodic-n1000-s01729,periodic,1000,1729,evolution/k-10,0.002054868749110028,1.7433459842800848e-06,0.0020532121852738783,0.002056612095094308,0.0020541428571699987,0.0020558554895886002,57 +dtmc,periodic-n1000-s01729,periodic,1000,1729,evolution/k-100,0.020488705749812652,1.73752156115356e-05,0.020471895833098743,0.020527516602305694,0.020475535105154114,0.020505285713755126,21 +dtmc,periodic-n1000-s01729,periodic,1000,1729,evolution/one-step,0.00021344546633370195,5.535182801104989e-07,0.000212916325513552,0.00021406224258164439,0.0002133037351826527,0.00021358136763681838,102 +dtmc,periodic-n1000-s01729,periodic,1000,1729,structure/classes-cold,0.00014743483323534883,5.027233985149349e-07,0.0001469493836921507,0.00014800338771720254,0.00014723352490507655,0.00014760325723465816,83 +dtmc,periodic-n1000-s01729,periodic,1000,1729,structure/classes-lifecycle,0.13268017277247662,0.0016093512105206653,0.13149480200445396,0.1341218184702614,0.13062125000578817,0.13496741660055706,8 +dtmc,periodic-n1000-s01729,periodic,1000,1729,structure/classes-warm/access,8.610994056858092e-09,1.177243326424987e-10,8.506434127353757e-09,1.0792173708912478e-08,8.564706715414261e-09,8.672950853851273e-09,309 +dtmc,periodic-n1000-s01729,periodic,1000,1729,structure/classes-warm/consumed,5.1077981884423945e-06,2.3570530534622323e-08,5.088106502105858e-06,5.144173511117165e-06,5.098701296079345e-06,5.115925774793186e-06,178 +dtmc,periodic-n1000-s01729,periodic,1000,1729,structure/cyclic-classes-cold,0.0003849328382380514,7.256665430144444e-07,0.00038427008110085046,0.00038559424146925183,0.00038453478514889465,0.0003852192592738127,63 +dtmc,periodic-n1000-s01729,periodic,1000,1729,structure/cyclic-classes-warm,8.852433652081745e-05,9.500534804513189e-08,8.838146958112467e-05,8.859956454630006e-05,8.849533133517342e-05,8.854861112518443e-05,119 +dtmc,periodic-n1000-s01729,periodic,1000,1729,structure/irreducible-cold,7.566868879118012e-05,3.980499900226519e-07,7.529620118227534e-05,7.609516340483613e-05,7.557741992059164e-05,7.585017875248593e-05,97 +dtmc,periodic-n1000-s01729,periodic,1000,1729,structure/irreducible-warm,9.76739989475811e-09,2.544043173290434e-10,9.525197302477035e-09,1.2085775057027457e-08,9.636829785978851e-09,9.887976295442279e-09,307 +dtmc,periodic-n1000-s01729,periodic,1000,1729,structure/period-cold,0.0002496366328779149,5.843322714864548e-07,0.00024904066352367715,0.00025018250523113747,0.00024935384283615656,0.000249855931342314,72 +dtmc,periodic-n1000-s01729,periodic,1000,1729,structure/period-warm,1.1885428503834352e-08,2.1495676222829376e-10,1.1678886808355441e-08,1.466058034389101e-08,1.174977786732072e-08,1.1992932145848089e-08,302 +dtmc,periodic-n1000-s02718,periodic,1000,2718,construction/public-consumed,0.13044615286950528,0.004171844057054841,0.12610676736429532,0.133760200983852,0.1257339464292662,0.13403171036370623,8 +dtmc,periodic-n1000-s02718,periodic,1000,2718,evolution/k-10,0.0019375319511802482,1.4808793827616974e-06,0.0019358322690153267,0.0019385122324680336,0.001936596033679589,0.0019379988287775113,58 +dtmc,periodic-n1000-s02718,periodic,1000,2718,evolution/k-100,0.01930427515921606,1.1722014107470868e-05,0.019294490265110653,0.019333373499778515,0.01929577054697267,0.01931174399630566,22 +dtmc,periodic-n1000-s02718,periodic,1000,2718,evolution/one-step,0.00020076443072329894,3.3975843896950366e-07,0.000200088528354707,0.00020107821430970354,0.00020066921239380133,0.00020083150812115832,103 +dtmc,periodic-n1000-s02718,periodic,1000,2718,structure/classes-cold,0.00014537176600872324,4.387317415420727e-07,0.0001450538755612007,0.0001461187754001016,0.0001452720646436016,0.00014557281429006252,83 +dtmc,periodic-n1000-s02718,periodic,1000,2718,structure/classes-lifecycle,0.1327792345695863,0.001199413054755058,0.13209685168840224,0.13378415193650048,0.13097319775260985,0.1343676390000231,8 +dtmc,periodic-n1000-s02718,periodic,1000,2718,structure/classes-warm/access,8.628617182566218e-09,1.4580980708889636e-10,8.498198562104796e-09,1.1295844377560533e-08,8.556378683565761e-09,8.773890547444002e-09,308 +dtmc,periodic-n1000-s02718,periodic,1000,2718,structure/classes-warm/consumed,5.0873348580869755e-06,7.268881600570079e-09,5.081421061292981e-06,5.103784992620554e-06,5.085095752815068e-06,5.090191772156586e-06,178 +dtmc,periodic-n1000-s02718,periodic,1000,2718,structure/cyclic-classes-cold,0.00038449037373958233,1.1746781993271819e-06,0.00038349328299485915,0.00038625532801562167,0.0003838725324865084,0.00038510981341294774,64 +dtmc,periodic-n1000-s02718,periodic,1000,2718,structure/cyclic-classes-warm,8.846619774671167e-05,9.440797833604024e-08,8.835597482801185e-05,8.852734262210739e-05,8.843620084267709e-05,8.848940194087121e-05,119 +dtmc,periodic-n1000-s02718,periodic,1000,2718,structure/irreducible-cold,7.578760980524951e-05,3.9488627590750485e-07,7.541904284702262e-05,7.619943665328988e-05,7.564807743458849e-05,7.58741416380318e-05,97 +dtmc,periodic-n1000-s02718,periodic,1000,2718,structure/irreducible-warm,9.76205402931533e-09,2.384570184743315e-10,9.548458230063197e-09,1.2651918199561867e-08,9.67292640703e-09,9.851217331215834e-09,305 +dtmc,periodic-n1000-s02718,periodic,1000,2718,structure/period-cold,0.000249453160179563,9.73998069547235e-07,0.0002483810384541094,0.0002503099967725575,0.000249081251968164,0.0002498186153672011,73 +dtmc,periodic-n1000-s02718,periodic,1000,2718,structure/period-warm,1.190041078722207e-08,2.4387917016340996e-10,1.1673433625474204e-08,1.4358247835699808e-08,1.182007101581819e-08,1.205114793643627e-08,302 +dtmc,periodic-n1000-s31415,periodic,1000,31415,construction/public-consumed,0.13039472741729696,0.003514929687298718,0.12686271578838515,0.13352373354191516,0.12537461314267212,0.13438860937822028,8 +dtmc,periodic-n1000-s31415,periodic,1000,31415,evolution/k-10,0.0019663356242485214,2.7130391049951744e-06,0.001963358669142343,0.0019685122267963837,0.00196510377082805,0.00196686154206258,58 +dtmc,periodic-n1000-s31415,periodic,1000,31415,evolution/k-100,0.01951682457920948,1.477458036357529e-05,0.019506211538100615,0.01953283333374808,0.019507628817915578,0.019522685224526666,21 +dtmc,periodic-n1000-s31415,periodic,1000,31415,evolution/one-step,0.00020631662076207356,5.089735662656394e-07,0.00020583197163514237,0.00020687077302873852,0.00020620625000447034,0.0002065300794791908,102 +dtmc,periodic-n1000-s31415,periodic,1000,31415,structure/classes-cold,0.00014672080726881406,6.898707135928671e-07,0.00014615051753378775,0.00014752711120728725,0.00014649766833624907,0.00014710655604075227,83 +dtmc,periodic-n1000-s31415,periodic,1000,31415,structure/classes-lifecycle,0.13288063200501105,0.00090945837473555,0.13231096356503258,0.13374277678758517,0.13180658325291006,0.1340946071431972,8 +dtmc,periodic-n1000-s31415,periodic,1000,31415,structure/classes-warm/access,8.657702863976453e-09,1.353969936120895e-10,8.538049628434197e-09,1.1075941604102337e-08,8.595529795666456e-09,8.729236897988905e-09,309 +dtmc,periodic-n1000-s31415,periodic,1000,31415,structure/classes-warm/consumed,5.098196559015047e-06,7.629962665702454e-09,5.092359374674179e-06,5.11421112542224e-06,5.095550852135586e-06,5.102270896638129e-06,178 +dtmc,periodic-n1000-s31415,periodic,1000,31415,structure/cyclic-classes-cold,0.0003845376598286018,1.0548377658673195e-06,0.000383607611469675,0.00038619762235729874,0.00038396465852401644,0.00038503909697531276,64 +dtmc,periodic-n1000-s31415,periodic,1000,31415,structure/cyclic-classes-warm,8.835794317686985e-05,1.0022993442619719e-07,8.822717487187227e-05,8.843931759585338e-05,8.832142873648174e-05,8.838881197266156e-05,119 +dtmc,periodic-n1000-s31415,periodic,1000,31415,structure/irreducible-cold,7.595675145109584e-05,3.0426378046469085e-07,7.570301471894388e-05,7.629271160706649e-05,7.586691936012357e-05,7.609292291677915e-05,97 +dtmc,periodic-n1000-s31415,periodic,1000,31415,structure/irreducible-warm,9.834159801518446e-09,3.3554944032826345e-10,9.51070500318678e-09,1.2051946794603084e-08,9.766223795546367e-09,9.884459313959254e-09,307 +dtmc,periodic-n1000-s31415,periodic,1000,31415,structure/period-cold,0.00024873362915394336,7.906083053099569e-07,0.00024796377654542754,0.0002495992678002669,0.0002482355843046994,0.0002491457955868639,73 +dtmc,periodic-n1000-s31415,periodic,1000,31415,structure/period-warm,1.1820305814587692e-08,1.7634894706003032e-10,1.165732386955744e-08,1.4511501157978278e-08,1.175451083566143e-08,1.1940308701596158e-08,302 +dtmc,reducible-n0010-s01729,reducible,10,1729,construction/public-consumed,6.378352598727642e-06,8.934030646315807e-09,6.369418568081326e-06,6.3858148038249325e-06,6.377044623409997e-06,6.3794219858452574e-06,173 +dtmc,reducible-n0010-s01729,reducible,10,1729,evolution/k-10,1.6469923151888098e-06,3.884463250716613e-09,1.643965510523011e-06,1.6594593526443114e-06,1.6457135695405444e-06,1.6479421752171574e-06,201 +dtmc,reducible-n0010-s01729,reducible,10,1729,evolution/k-100,3.0539532939664135e-06,8.190648553569638e-09,3.0465734604726694e-06,3.07141123288708e-06,3.0526721387932234e-06,3.055096679036656e-06,188 +dtmc,reducible-n0010-s01729,reducible,10,1729,evolution/one-step,2.4336644358089626e-07,9.101841921695358e-09,2.3425086526277517e-07,2.5193295777612124e-07,2.425528061610579e-07,2.4410049686909167e-07,241 +dtmc,reducible-n0010-s01729,reducible,10,1729,finite-time/n-step/k-10,2.894816575126721e-06,5.988949317848123e-09,2.8911623123970747e-06,2.913841541741571e-06,2.8939844153868163e-06,2.8965144696983507e-06,164 +dtmc,reducible-n0010-s01729,reducible,10,1729,finite-time/n-step/k-100,1.7425922635343034e-05,1.9044827101987244e-08,1.741063665883941e-05,1.745654679552822e-05,1.742109381507723e-05,1.7432868202309503e-05,140 +dtmc,reducible-n0010-s01729,reducible,10,1729,finite-time/observation/k-10,3.3203551855769497e-06,1.4473134809616309e-08,3.310319316956485e-06,3.341392254118215e-06,3.3173296471616584e-06,3.3248229668536707e-06,161 +dtmc,reducible-n0010-s01729,reducible,10,1729,finite-time/observation/k-100,1.790221436314594e-05,3.947820089549161e-08,1.787707017743139e-05,1.795831237607424e-05,1.7896231097839354e-05,1.7911659499619034e-05,138 +dtmc,reducible-n0010-s01729,reducible,10,1729,finite-time/step,7.582998745526899e-07,3.034731926427573e-09,7.554547165566398e-07,7.642801674655007e-07,7.57372346580834e-07,7.589227854482179e-07,191 +dtmc,reducible-n0010-s01729,reducible,10,1729,hitting-probability/cold-all-states,1.4589844235720542e-05,1.3915324906030579e-07,1.4474328574059265e-05,1.4819454394676017e-05,1.4539783992602125e-05,1.4627521734496681e-05,137 +dtmc,reducible-n0010-s01729,reducible,10,1729,hitting-probability/warm-lookup,2.4318140310470505e-08,7.39600930966678e-10,2.360978511772582e-08,2.7924805911043327e-08,2.413060114083247e-08,2.4897115110040295e-08,288 +dtmc,reducible-n0010-s01729,reducible,10,1729,hitting-time/cold-all-states,7.1581685698193775e-06,1.69851519017115e-08,7.142233937258023e-06,7.175711549020239e-06,7.152135227004002e-06,7.161184265795681e-06,145 +dtmc,reducible-n0010-s01729,reducible,10,1729,hitting-time/warm-lookup,2.4144184093468855e-08,2.6818778165319006e-10,2.3896501614551436e-08,2.746647980433745e-08,2.4035397341949475e-08,2.4381268444990315e-08,287 +dtmc,reducible-n0010-s01729,reducible,10,1729,hitting/bounded/at-most/k-10,3.2787013230429046e-06,1.3549056075270341e-08,3.2697372310059634e-06,3.2969502663159003e-06,3.275682560188022e-06,3.2837834288476676e-06,161 +dtmc,reducible-n0010-s01729,reducible,10,1729,hitting/bounded/at-most/k-100,1.894647353020194e-05,4.096584956605963e-08,1.8917966237544428e-05,1.9089083185320028e-05,1.893285638516484e-05,1.8965512084035185e-05,139 +dtmc,reducible-n0010-s01729,reducible,10,1729,hitting/bounded/exact/k-10,3.2651781100657832e-06,1.494681236597545e-08,3.255178135556267e-06,3.356701095721551e-06,3.262236412851223e-06,3.269298579455112e-06,162 +dtmc,reducible-n0010-s01729,reducible,10,1729,hitting/bounded/exact/k-100,1.8680572978999578e-05,1.8750060744914058e-08,1.866770269253227e-05,1.8716059607465433e-05,1.867562101359445e-05,1.8689402965649676e-05,139 +dtmc,reducible-n0010-s01729,reducible,10,1729,hitting/bounded/greater-than/k-10,3.2580533505616978e-06,1.4036525596042083e-08,3.2436864627793395e-06,3.270468152840149e-06,3.2556302761739365e-06,3.2599445314384956e-06,162 +dtmc,reducible-n0010-s01729,reducible,10,1729,hitting/bounded/greater-than/k-100,1.9018130229855193e-05,2.8987689471741214e-08,1.89908805670764e-05,1.905386731559081e-05,1.9011543623987563e-05,1.9022703094428898e-05,138 +dtmc,reducible-n0010-s01729,reducible,10,1729,occupation-matrix,3.076651301045826e-05,7.134533571719919e-08,3.0711326950157714e-05,3.0920580546198336e-05,3.075127899319732e-05,3.079994249138471e-05,130 +dtmc,reducible-n0010-s01729,reducible,10,1729,power/10,4.3964911319053066e-06,7.336772137043474e-09,4.3908766415974784e-06,4.420623424396451e-06,4.394769350195446e-06,4.399349710942944e-06,180 +dtmc,reducible-n0010-s01729,reducible,10,1729,power/100,5.706639060225269e-06,8.364185283223033e-09,5.699471794910401e-06,5.717541042431951e-06,5.7055861534662655e-06,5.708660412048606e-06,175 +dtmc,reducible-n0010-s01729,reducible,10,1729,power/2,3.354470083449395e-06,4.685779862888463e-09,3.35223029056476e-06,3.3770206344159365e-06,3.353649140773355e-06,3.356703068586249e-06,186 +dtmc,reducible-n0010-s01729,reducible,10,1729,return/bounded/k-10,2.9644450276262232e-06,1.3257000168863877e-08,2.9528451710766044e-06,2.9927618365014325e-06,2.959542125822287e-06,2.9713546184857734e-06,163 +dtmc,reducible-n0010-s01729,reducible,10,1729,return/bounded/k-100,1.8332093781745973e-05,2.2226278644419496e-08,1.8309098067246357e-05,1.8353879696473495e-05,1.8327496132770245e-05,1.8334726973989746e-05,139 +dtmc,reducible-n0010-s01729,reducible,10,1729,stationary,6.578955822920694e-06,4.2079145040824486e-08,6.551954000687256e-06,6.7172949637092636e-06,6.570668889096341e-06,6.601356837354534e-06,147 +dtmc,reducible-n0010-s01729,reducible,10,1729,structure/classes-cold,3.167668710212267e-06,1.6311163263549115e-08,3.154225357647819e-06,3.195873284696535e-06,3.162976428012322e-06,3.175408579992658e-06,162 +dtmc,reducible-n0010-s01729,reducible,10,1729,structure/classes-lifecycle,8.71324647708067e-06,2.088268123340451e-07,8.55104258702823e-06,9.291007410663749e-06,8.658018715843653e-06,8.817235745108551e-06,166 +dtmc,reducible-n0010-s01729,reducible,10,1729,structure/classes-warm/access,8.59060104614514e-09,8.422905174445147e-11,8.517532341817918e-09,1.0893697550670169e-08,8.552000602582601e-09,8.670984463447925e-09,309 +dtmc,reducible-n0010-s01729,reducible,10,1729,structure/classes-warm/consumed,4.4177529016806946e-08,3.7692264460845e-10,4.387781807174999e-08,4.774657838342156e-08,4.405362434310549e-08,4.4429225965571664e-08,275 +dtmc,reducible-n0010-s01729,reducible,10,1729,structure/irreducible-cold,2.1013837195812965e-06,5.935689767795759e-09,2.097154169659366e-06,2.1107257457497657e-06,2.0997938634356973e-06,2.1042069420218468e-06,170 +dtmc,reducible-n0010-s01729,reducible,10,1729,structure/irreducible-warm,9.364867841977734e-09,7.773654581122885e-11,9.299881261000595e-09,1.1766184971555476e-08,9.328553027033588e-09,9.443601252817645e-09,307 +dtmc,reducible-n0010-s01729,reducible,10,1729,visits/bounded-expectation/k-10,5.101450006029949e-06,2.022378793162044e-08,5.074865307213475e-06,5.119609383215847e-06,5.097139663576313e-06,5.109123819220136e-06,152 +dtmc,reducible-n0010-s01729,reducible,10,1729,visits/bounded-expectation/k-100,3.688938561369706e-05,3.777187571199432e-08,3.686111327354671e-05,3.694250895373093e-05,3.6879145083826426e-05,3.690175333134244e-05,130 +dtmc,reducible-n0010-s02718,reducible,10,2718,construction/public-consumed,6.347653969661602e-06,7.383443851592419e-09,6.343054513376998e-06,6.3712411419514595e-06,6.347131944595882e-06,6.349696547790431e-06,172 +dtmc,reducible-n0010-s02718,reducible,10,2718,evolution/k-10,1.6419723612704762e-06,2.7399067353060324e-09,1.6399398351988642e-06,1.6488970597457213e-06,1.641277309528971e-06,1.6428723996616923e-06,201 +dtmc,reducible-n0010-s02718,reducible,10,2718,evolution/k-100,3.0484091432009837e-06,1.0734037904558631e-08,3.0395336244782978e-06,3.060624035475648e-06,3.044875995230101e-06,3.050086172978247e-06,188 +dtmc,reducible-n0010-s02718,reducible,10,2718,evolution/one-step,2.462852547107842e-07,6.6555528270160165e-09,2.429743459399667e-07,2.5421345679696355e-07,2.4529980161636557e-07,2.472215462202097e-07,241 +dtmc,reducible-n0010-s02718,reducible,10,2718,finite-time/n-step/k-10,2.903688561276992e-06,8.889376800375866e-09,2.8969719264856107e-06,2.9159768658802747e-06,2.901909435119402e-06,2.9064103525583333e-06,164 +dtmc,reducible-n0010-s02718,reducible,10,2718,finite-time/n-step/k-100,1.7358762768278104e-05,2.1230931274594927e-08,1.7344314758680588e-05,1.739690982105868e-05,1.7354714304838704e-05,1.736571074515167e-05,140 +dtmc,reducible-n0010-s02718,reducible,10,2718,finite-time/observation/k-10,3.333451706965441e-06,1.0552399734251111e-08,3.325077753630716e-06,3.3510205674729573e-06,3.3312891866787217e-06,3.336622607370489e-06,159 +dtmc,reducible-n0010-s02718,reducible,10,2718,finite-time/observation/k-100,1.800425267109888e-05,9.905044214102256e-08,1.7918684948196997e-05,1.8211145258862897e-05,1.7972864596157066e-05,1.804020602894188e-05,138 +dtmc,reducible-n0010-s02718,reducible,10,2718,finite-time/step,7.552536220153731e-07,4.773238328678061e-09,7.505114471570966e-07,7.60048659038724e-07,7.539513978489334e-07,7.568347537329682e-07,191 +dtmc,reducible-n0010-s02718,reducible,10,2718,hitting-probability/cold-all-states,1.454096154797253e-05,4.579121723542461e-08,1.4504602191098496e-05,1.462828642557255e-05,1.452732611628379e-05,1.456151753073319e-05,138 +dtmc,reducible-n0010-s02718,reducible,10,2718,hitting-probability/warm-lookup,2.4156616612600776e-08,5.379495454566667e-10,2.365274229774916e-08,2.7161041544403243e-08,2.395516195110422e-08,2.433393017698e-08,288 +dtmc,reducible-n0010-s02718,reducible,10,2718,hitting-time/cold-all-states,7.208083801763668e-06,2.445340093361992e-08,7.185911808461739e-06,7.23269175000067e-06,7.2019611252471805e-06,7.2141777255309786e-06,145 +dtmc,reducible-n0010-s02718,reducible,10,2718,hitting-time/warm-lookup,2.4049307914845724e-08,1.742296326051329e-10,2.3886633731491333e-08,2.72273170124678e-08,2.396582117542907e-08,2.4137896036593187e-08,288 +dtmc,reducible-n0010-s02718,reducible,10,2718,hitting/bounded/at-most/k-10,3.3394221708327718e-06,9.910555926378721e-09,3.3312088917180194e-06,3.3562454128904003e-06,3.3369991191041968e-06,3.3434557781068987e-06,161 +dtmc,reducible-n0010-s02718,reducible,10,2718,hitting/bounded/at-most/k-100,1.9065398789410082e-05,9.933833337692974e-08,1.898559478235633e-05,1.991591552485479e-05,1.9022714695893228e-05,1.917902343186804e-05,139 +dtmc,reducible-n0010-s02718,reducible,10,2718,hitting/bounded/exact/k-10,3.2693910045849008e-06,1.189502920638118e-08,3.2615380130759147e-06,3.306216651411808e-06,3.2667743987299818e-06,3.2738415990310617e-06,161 +dtmc,reducible-n0010-s02718,reducible,10,2718,hitting/bounded/exact/k-100,1.876466763445582e-05,4.530298710644001e-08,1.873145273781718e-05,1.8930626929915097e-05,1.8758198712021114e-05,1.8779303268087354e-05,139 +dtmc,reducible-n0010-s02718,reducible,10,2718,hitting/bounded/greater-than/k-10,3.297597240638353e-06,7.983327921091944e-09,3.2903524706950876e-06,3.3075835692663545e-06,3.295040223747492e-06,3.299541987652408e-06,161 +dtmc,reducible-n0010-s02718,reducible,10,2718,hitting/bounded/greater-than/k-100,1.8990880704105495e-05,1.6485907717709214e-08,1.8977559459703802e-05,1.9017565223510334e-05,1.8984978948793505e-05,1.899397356505945e-05,139 +dtmc,reducible-n0010-s02718,reducible,10,2718,occupation-matrix,3.065787390879931e-05,6.377364413647462e-08,3.0618684757993754e-05,3.083636390025883e-05,3.064439741229531e-05,3.069352927830828e-05,130 +dtmc,reducible-n0010-s02718,reducible,10,2718,power/10,4.372255193022596e-06,1.0318849962263107e-08,4.365226694255298e-06,4.3869047978340266e-06,4.37008453496981e-06,4.378355691450079e-06,181 +dtmc,reducible-n0010-s02718,reducible,10,2718,power/100,5.673649965005936e-06,1.2151229587429708e-08,5.6633388175625545e-06,5.687305421531477e-06,5.671629111351802e-06,5.677655438682454e-06,176 +dtmc,reducible-n0010-s02718,reducible,10,2718,power/2,3.3177878792240834e-06,6.41969487812385e-09,3.3133298141026892e-06,3.334126739792845e-06,3.3163576864971573e-06,3.319041566897453e-06,187 +dtmc,reducible-n0010-s02718,reducible,10,2718,return/bounded/k-10,2.982971976650019e-06,9.66481916512405e-09,2.9751105670988958e-06,2.9971906943024977e-06,2.9800415064855805e-06,2.9865556579326916e-06,163 +dtmc,reducible-n0010-s02718,reducible,10,2718,return/bounded/k-100,1.837828220375244e-05,1.7516581549106207e-08,1.8365183097734475e-05,1.8405671856306528e-05,1.8374160213613468e-05,1.8383098382945294e-05,139 +dtmc,reducible-n0010-s02718,reducible,10,2718,stationary,6.684486418119591e-06,4.257099159385198e-08,6.645523434834952e-06,6.73135477855028e-06,6.672597300464741e-06,6.694750542415189e-06,147 +dtmc,reducible-n0010-s02718,reducible,10,2718,structure/classes-cold,3.1628114389611747e-06,3.0209370910655334e-08,3.142360567781589e-06,3.321103389940358e-06,3.1571985435853768e-06,3.174948774889802e-06,162 +dtmc,reducible-n0010-s02718,reducible,10,2718,structure/classes-lifecycle,8.516611362748666e-06,4.230678156383546e-08,8.479650347065624e-06,8.575677138854301e-06,8.504797553078086e-06,8.528301845240236e-06,167 +dtmc,reducible-n0010-s02718,reducible,10,2718,structure/classes-warm/access,8.551830966596728e-09,6.41879096861759e-11,8.498375450253902e-09,1.0775860489999084e-08,8.527133645462388e-09,8.621045963839012e-09,309 +dtmc,reducible-n0010-s02718,reducible,10,2718,structure/classes-warm/consumed,4.401831889967665e-08,3.018001005670116e-10,4.376495161320834e-08,4.731540426420266e-08,4.392070619694157e-08,4.430992948371905e-08,275 +dtmc,reducible-n0010-s02718,reducible,10,2718,structure/irreducible-cold,2.1168369135824056e-06,1.1439490572471987e-08,2.1053511130958937e-06,2.1280723187894726e-06,2.11350033297021e-06,2.1194928739276473e-06,170 +dtmc,reducible-n0010-s02718,reducible,10,2718,structure/irreducible-warm,9.457944743679128e-09,1.6264600185925554e-10,9.308181053461245e-09,1.2149227292066142e-08,9.370479542402277e-09,9.574173875965918e-09,306 +dtmc,reducible-n0010-s02718,reducible,10,2718,visits/bounded-expectation/k-10,5.142125457438688e-06,2.012331714323053e-08,5.126899283998654e-06,5.1778258471515995e-06,5.136669646514681e-06,5.149432039652678e-06,152 +dtmc,reducible-n0010-s02718,reducible,10,2718,visits/bounded-expectation/k-100,3.691809208397457e-05,9.267945984626819e-08,3.685390579940108e-05,3.884850285616141e-05,3.688764420960954e-05,3.708490813824865e-05,130 +dtmc,reducible-n0010-s31415,reducible,10,31415,construction/public-consumed,6.354210600768866e-06,9.018222847672106e-09,6.345834117382765e-06,6.36619587726507e-06,6.352781238014709e-06,6.355495181183469e-06,173 +dtmc,reducible-n0010-s31415,reducible,10,31415,evolution/k-10,1.645685021632863e-06,6.241374605748614e-09,1.6412545016503401e-06,1.660714458142008e-06,1.6437757208391471e-06,1.6483624079018865e-06,201 +dtmc,reducible-n0010-s31415,reducible,10,31415,evolution/k-100,3.07344298435596e-06,2.3206568309002223e-08,3.0519525321047754e-06,3.1052637345218194e-06,3.0688332866274697e-06,3.0813412678240923e-06,188 +dtmc,reducible-n0010-s31415,reducible,10,31415,evolution/one-step,2.4341867480537677e-07,8.822278148894072e-09,2.3458137445587536e-07,2.5150728870885097e-07,2.426992410206232e-07,2.4425500782414345e-07,241 +dtmc,reducible-n0010-s31415,reducible,10,31415,finite-time/n-step/k-10,2.934634918883477e-06,1.0840108308120071e-08,2.924826856263603e-06,2.945652126291508e-06,2.9318994778696546e-06,2.9370383731926134e-06,164 +dtmc,reducible-n0010-s31415,reducible,10,31415,finite-time/n-step/k-100,1.7412209356884485e-05,2.412224756911321e-08,1.7392537871648522e-05,1.7450731028518895e-05,1.7406200198344856e-05,1.742321363262898e-05,140 +dtmc,reducible-n0010-s31415,reducible,10,31415,finite-time/observation/k-10,3.3697795840231955e-06,1.040043596674912e-08,3.360085222095854e-06,3.384122080034644e-06,3.367571921150592e-06,3.3729630381793983e-06,161 +dtmc,reducible-n0010-s31415,reducible,10,31415,finite-time/observation/k-100,1.7900948614101514e-05,2.042013827882868e-08,1.7885500181828853e-05,1.7933821339922357e-05,1.7894059559891383e-05,1.790778871272482e-05,139 +dtmc,reducible-n0010-s31415,reducible,10,31415,finite-time/step,7.566489260705603e-07,4.910573921146818e-09,7.531725540238972e-07,7.654926706051741e-07,7.554104966992462e-07,7.581334062481085e-07,191 +dtmc,reducible-n0010-s31415,reducible,10,31415,hitting-probability/cold-all-states,1.4472914941222215e-05,8.710937541789747e-08,1.4396452187401927e-05,1.4610295865385826e-05,1.4451437977982621e-05,1.4502177509712056e-05,138 +dtmc,reducible-n0010-s31415,reducible,10,31415,hitting-probability/warm-lookup,2.3730160982497894e-08,1.5166080542797709e-10,2.361352293456871e-08,2.7464856872757922e-08,2.3679789421449376e-08,2.3996403119725968e-08,288 +dtmc,reducible-n0010-s31415,reducible,10,31415,hitting-time/cold-all-states,7.160855262354404e-06,1.1475729542128363e-08,7.149706847879306e-06,7.174322630037814e-06,7.155891795772859e-06,7.163589485102303e-06,145 +dtmc,reducible-n0010-s31415,reducible,10,31415,hitting-time/warm-lookup,2.400509345839027e-08,1.3994036297227975e-10,2.3884194201938047e-08,2.8773881770046118e-08,2.3942466064829523e-08,2.4127569763720402e-08,288 +dtmc,reducible-n0010-s31415,reducible,10,31415,hitting/bounded/at-most/k-10,3.366721472863493e-06,1.3222422145692161e-08,3.3546984819507404e-06,3.3882097341120243e-06,3.3629126409686475e-06,3.371673412811087e-06,161 +dtmc,reducible-n0010-s31415,reducible,10,31415,hitting/bounded/at-most/k-100,1.905551309339223e-05,2.0745135046075633e-08,1.9030297739622608e-05,1.9069437835805304e-05,1.9049020715084775e-05,1.9060406060323607e-05,139 +dtmc,reducible-n0010-s31415,reducible,10,31415,hitting/bounded/exact/k-10,3.2798674224425903e-06,1.4552924112710175e-08,3.266079949167699e-06,3.2977401387206344e-06,3.2753799342973296e-06,3.285355398572582e-06,161 +dtmc,reducible-n0010-s31415,reducible,10,31415,hitting/bounded/exact/k-100,1.8778787177455213e-05,2.1647028061170024e-08,1.8761280662560323e-05,1.8810184858397227e-05,1.8773319898173213e-05,1.8785506938024223e-05,139 +dtmc,reducible-n0010-s31415,reducible,10,31415,hitting/bounded/greater-than/k-10,3.2643431246899888e-06,1.569120644747288e-08,3.254739886002043e-06,3.4853510442189872e-06,3.259697903154625e-06,3.2694627704742657e-06,161 +dtmc,reducible-n0010-s31415,reducible,10,31415,hitting/bounded/greater-than/k-100,1.8966609185740665e-05,2.357352849293313e-08,1.8948236933239066e-05,1.9000065755318096e-05,1.8960901490547103e-05,1.8972879453772414e-05,139 +dtmc,reducible-n0010-s31415,reducible,10,31415,occupation-matrix,3.0722063008583e-05,6.592646891187963e-08,3.0676331071175746e-05,3.0821878248215873e-05,3.070271276877899e-05,3.074253229681119e-05,130 +dtmc,reducible-n0010-s31415,reducible,10,31415,power/10,4.3689636884770096e-06,1.347689625689493e-08,4.358577763556324e-06,4.3932965280454374e-06,4.365811793788244e-06,4.371920361088335e-06,181 +dtmc,reducible-n0010-s31415,reducible,10,31415,power/100,5.687018469404142e-06,2.0353372188993058e-08,5.666886308551651e-06,5.707384684077833e-06,5.682220770007088e-06,5.691025702270821e-06,176 +dtmc,reducible-n0010-s31415,reducible,10,31415,power/2,3.3296024927649974e-06,1.4841427359237983e-08,3.316481475965414e-06,3.3577762741320384e-06,3.324707689259961e-06,3.332536794773691e-06,186 +dtmc,reducible-n0010-s31415,reducible,10,31415,return/bounded/k-10,3.0212417861792382e-06,9.3269633964086e-09,3.013227454266193e-06,3.039120753134702e-06,3.0177991772818913e-06,3.025074043781847e-06,163 +dtmc,reducible-n0010-s31415,reducible,10,31415,return/bounded/k-100,1.8462854110743706e-05,3.447302905067263e-08,1.843676744556637e-05,1.853083574472964e-05,1.8448914482404166e-05,1.8479124264558777e-05,139 +dtmc,reducible-n0010-s31415,reducible,10,31415,stationary,6.6713151422196205e-06,3.440549161972631e-08,6.643697399865018e-06,6.727115162734494e-06,6.6642587626120076e-06,6.6802474389445785e-06,147 +dtmc,reducible-n0010-s31415,reducible,10,31415,structure/classes-cold,3.2820308897088368e-06,1.3051131693751537e-08,3.268559642795784e-06,3.29306540251915e-06,3.279058232126663e-06,3.285565539332322e-06,161 +dtmc,reducible-n0010-s31415,reducible,10,31415,structure/classes-lifecycle,8.533726421384407e-06,4.1081436838621396e-08,8.497300245821366e-06,8.65872262510736e-06,8.524540909188617e-06,8.544743232841062e-06,167 +dtmc,reducible-n0010-s31415,reducible,10,31415,structure/classes-warm/access,9.316373787670627e-09,8.096533022679247e-10,8.806882453546872e-09,1.2338568922132253e-08,9.14122342791459e-09,9.536869235954801e-09,309 +dtmc,reducible-n0010-s31415,reducible,10,31415,structure/classes-warm/consumed,4.404080072512855e-08,3.224040567901686e-10,4.3762345116830115e-08,4.769061574712755e-08,4.3899837609885924e-08,4.431279658763404e-08,275 +dtmc,reducible-n0010-s31415,reducible,10,31415,structure/irreducible-cold,2.1700813834156307e-06,1.0095885549168643e-08,2.162251413600253e-06,2.1865908788826453e-06,2.166542937188889e-06,2.173483485350704e-06,169 +dtmc,reducible-n0010-s31415,reducible,10,31415,structure/irreducible-warm,9.405888114094909e-09,1.220827224641551e-10,9.306305993043675e-09,1.1792971205290746e-08,9.3564318371079e-09,9.520817151849518e-09,307 +dtmc,reducible-n0010-s31415,reducible,10,31415,visits/bounded-expectation/k-10,5.13270355267672e-06,3.0422930261505876e-08,5.104125613931944e-06,5.167352909376052e-06,5.121599837523941e-06,5.142070533591192e-06,152 +dtmc,reducible-n0010-s31415,reducible,10,31415,visits/bounded-expectation/k-100,3.69050149669102e-05,6.92590162394756e-08,3.6852782976037134e-05,3.702814657344789e-05,3.688071873393905e-05,3.6933836009559696e-05,130 +dtmc,reducible-n0025-s01729,reducible,25,1729,construction/public-consumed,3.7068182295611635e-05,5.517008650154264e-08,3.7030542331233764e-05,3.717244382844203e-05,3.705367601184924e-05,3.7105142837390304e-05,137 +dtmc,reducible-n0025-s01729,reducible,25,1729,evolution/k-10,2.322129597960952e-06,6.003360526312326e-09,2.3173908966198367e-06,2.329992600677863e-06,2.3211628536353197e-06,2.323085632213609e-06,194 +dtmc,reducible-n0025-s01729,reducible,25,1729,evolution/k-100,8.720140783048657e-06,4.4907176294733554e-08,8.62595692384415e-06,8.745186099499043e-06,8.705403480123272e-06,8.729353971548576e-06,167 +dtmc,reducible-n0025-s01729,reducible,25,1729,evolution/one-step,3.9475719986265755e-07,8.008044830628065e-09,3.8672264287272887e-07,4.017128010513678e-07,3.9189955850063956e-07,3.9549435614765587e-07,231 +dtmc,reducible-n0025-s01729,reducible,25,1729,finite-time/n-step/k-10,3.706903249445942e-06,9.62907836320572e-09,3.698119758417706e-06,3.717862244936839e-06,3.7034366374151616e-06,3.709268365920039e-06,159 +dtmc,reducible-n0025-s01729,reducible,25,1729,finite-time/n-step/k-100,2.415885870245152e-05,2.8745473118662042e-08,2.413653673522827e-05,2.4207831493664632e-05,2.4149677639047636e-05,2.416324923749212e-05,122 +dtmc,reducible-n0025-s01729,reducible,25,1729,finite-time/observation/k-10,4.4989870258904115e-06,7.1325357966263035e-09,4.493196332208709e-06,4.508776020420275e-06,4.497148278032375e-06,4.500511521097993e-06,155 +dtmc,reducible-n0025-s01729,reducible,25,1729,finite-time/observation/k-100,2.4957989808171988e-05,2.208308659137979e-08,2.4939001797555156e-05,2.498158654715452e-05,2.4952122204370207e-05,2.496747477773768e-05,121 +dtmc,reducible-n0025-s01729,reducible,25,1729,finite-time/step,8.067096049123345e-07,4.259458410514047e-09,8.024496566039931e-07,8.108610728472822e-07,8.059133629802968e-07,8.082707405059762e-07,190 +dtmc,reducible-n0025-s01729,reducible,25,1729,hitting-probability/cold-all-states,4.08190634458306e-05,7.122806047281632e-08,4.076393184572875e-05,4.094901638122143e-05,4.079736721027514e-05,4.086740033623452e-05,111 +dtmc,reducible-n0025-s01729,reducible,25,1729,hitting-probability/warm-lookup,2.401619454677082e-08,4.097186784652392e-10,2.361686008335962e-08,2.7575571528779197e-08,2.370605638137476e-08,2.421809195024484e-08,288 +dtmc,reducible-n0025-s01729,reducible,25,1729,hitting-time/cold-all-states,2.41552048777109e-05,2.4137308500573316e-08,2.413580183262688e-05,2.4188661890468805e-05,2.414793299819066e-05,2.4162314386566666e-05,120 +dtmc,reducible-n0025-s01729,reducible,25,1729,hitting-time/warm-lookup,2.4050015650977856e-08,1.7216015539711568e-10,2.389084203625157e-08,2.7189449498104227e-08,2.3967147816007106e-08,2.4124618383130386e-08,288 +dtmc,reducible-n0025-s01729,reducible,25,1729,hitting/bounded/at-most/k-10,4.252331011829238e-06,8.717479514627998e-09,4.245506228994313e-06,4.268861883896296e-06,4.249605839943577e-06,4.255884170609026e-06,156 +dtmc,reducible-n0025-s01729,reducible,25,1729,hitting/bounded/at-most/k-100,2.5105040347423506e-05,2.4061255503475608e-08,2.5086440886794165e-05,2.515367942933067e-05,2.509740376071124e-05,2.5113234005402774e-05,121 +dtmc,reducible-n0025-s01729,reducible,25,1729,hitting/bounded/exact/k-10,4.212638850948631e-06,1.1338182057225986e-08,4.204803173548159e-06,4.2329238921122814e-06,4.210118408009398e-06,4.216279658290074e-06,156 +dtmc,reducible-n0025-s01729,reducible,25,1729,hitting/bounded/exact/k-100,2.5013906068409827e-05,2.5760175197261996e-08,2.499107733121869e-05,2.5044186259037815e-05,2.500382005247014e-05,2.5023700436577202e-05,121 +dtmc,reducible-n0025-s01729,reducible,25,1729,hitting/bounded/greater-than/k-10,4.2575631737292935e-06,8.745044230954482e-09,4.250697230770974e-06,4.269319986063427e-06,4.2556734611873035e-06,4.260689944610133e-06,156 +dtmc,reducible-n0025-s01729,reducible,25,1729,hitting/bounded/greater-than/k-100,2.54058298398789e-05,3.263128144236866e-08,2.538251591789903e-05,2.545518170948486e-05,2.539063037930997e-05,2.542094537405979e-05,121 +dtmc,reducible-n0025-s01729,reducible,25,1729,occupation-matrix,0.00017318573718203895,1.774190302268532e-07,0.00017305797664448618,0.00017340984976888725,0.00017312377211496687,0.0001732593961772794,97 +dtmc,reducible-n0025-s01729,reducible,25,1729,power/10,1.6498246627137803e-05,4.864436155912574e-08,1.6457088750615393e-05,1.6552408725118726e-05,1.648150095938206e-05,1.6508700305227506e-05,154 +dtmc,reducible-n0025-s01729,reducible,25,1729,power/100,2.0494299370425643e-05,1.3674642758474312e-07,2.0306819351390004e-05,2.0615722557219367e-05,2.04306958687572e-05,2.052171611605938e-05,149 +dtmc,reducible-n0025-s01729,reducible,25,1729,power/2,1.3183570707510996e-05,2.345611567352504e-08,1.3168523831773212e-05,1.3250714400783182e-05,1.3174778891035017e-05,1.319000031799078e-05,158 +dtmc,reducible-n0025-s01729,reducible,25,1729,return/bounded/k-10,3.723441218713423e-06,1.0486476580714577e-08,3.7153613995713715e-06,3.7557737935459545e-06,3.7211766477785314e-06,3.72798224721247e-06,158 +dtmc,reducible-n0025-s01729,reducible,25,1729,return/bounded/k-100,2.4709098169905612e-05,5.2254390428470185e-08,2.4668357252518883e-05,2.5073712783018696e-05,2.4684894015081227e-05,2.4771362303807917e-05,122 +dtmc,reducible-n0025-s01729,reducible,25,1729,stationary,1.432167649120429e-05,2.999203654064508e-08,1.429707246443957e-05,1.4358291453539336e-05,1.4315104194226475e-05,1.433024056185084e-05,131 +dtmc,reducible-n0025-s01729,reducible,25,1729,structure/classes-cold,9.413920451484207e-06,1.6560515604269916e-08,9.403381703069295e-06,9.4388760134363e-06,9.409136096523566e-06,9.422708407496777e-06,140 +dtmc,reducible-n0025-s01729,reducible,25,1729,structure/classes-lifecycle,4.821528415131726e-05,4.91729478702371e-08,4.817102276170013e-05,4.82666600021463e-05,4.820538850240132e-05,4.822672673740496e-05,132 +dtmc,reducible-n0025-s01729,reducible,25,1729,structure/classes-warm/access,8.565759745115886e-09,7.791332038862527e-11,8.499166472361805e-09,1.0816923653086027e-08,8.530741049784718e-09,8.627122351119731e-09,309 +dtmc,reducible-n0025-s01729,reducible,25,1729,structure/classes-warm/consumed,1.1309877675676518e-07,5.186335428464736e-10,1.1266985786744587e-07,1.1787378530438987e-07,1.1289233230351364e-07,1.133654980680289e-07,256 +dtmc,reducible-n0025-s01729,reducible,25,1729,structure/irreducible-cold,7.232285921193966e-06,2.135189725032599e-08,7.20673798289346e-06,7.252284820128994e-06,7.226576367464229e-06,7.241498036707484e-06,145 +dtmc,reducible-n0025-s01729,reducible,25,1729,structure/irreducible-warm,9.421915842418756e-09,1.1446294081164606e-10,9.326450159080584e-09,1.170513912609907e-08,9.36868915930194e-09,9.52084274058651e-09,307 +dtmc,reducible-n0025-s01729,reducible,25,1729,visits/bounded-expectation/k-10,6.086158629676158e-06,2.0025007859651615e-08,6.066143257720839e-06,6.106342066471514e-06,6.077226105216937e-06,6.0934556900312786e-06,149 +dtmc,reducible-n0025-s01729,reducible,25,1729,visits/bounded-expectation/k-100,4.3277731553340955e-05,3.360473413408405e-08,4.32515359081715e-05,4.332563416524367e-05,4.327289861976169e-05,4.3296040084310796e-05,117 +dtmc,reducible-n0025-s02718,reducible,25,2718,construction/public-consumed,3.715384697828155e-05,7.34261149162784e-08,3.709332086145878e-05,3.7251050366840066e-05,3.713875564555632e-05,3.718479402285098e-05,137 +dtmc,reducible-n0025-s02718,reducible,25,2718,evolution/k-10,2.3247308582619804e-06,4.622745215026251e-09,2.321519736284977e-06,2.3402248090434817e-06,2.3240560449589287e-06,2.3255884560497643e-06,194 +dtmc,reducible-n0025-s02718,reducible,25,2718,evolution/k-100,8.754632772201049e-06,4.612172074604405e-08,8.671549983339104e-06,8.78515779145685e-06,8.744097160182983e-06,8.761516361767783e-06,167 +dtmc,reducible-n0025-s02718,reducible,25,2718,evolution/one-step,3.9717905228911417e-07,9.85367024216947e-09,3.8747126523819736e-07,4.0864909312255253e-07,3.965346472300958e-07,3.988816384610525e-07,230 +dtmc,reducible-n0025-s02718,reducible,25,2718,finite-time/n-step/k-10,3.821060732554863e-06,9.307343975650917e-08,3.7423891802955913e-06,4.063467955408043e-06,3.783672582358122e-06,3.871423056504379e-06,159 +dtmc,reducible-n0025-s02718,reducible,25,2718,finite-time/n-step/k-100,2.4251675753750607e-05,3.3163437794234195e-08,2.422638415845303e-05,2.4302207993662633e-05,2.4241367722616385e-05,2.426471269077242e-05,122 +dtmc,reducible-n0025-s02718,reducible,25,2718,finite-time/observation/k-10,4.524642711410045e-06,1.2929760229937126e-08,4.514191848134333e-06,4.543740542754162e-06,4.519704610706782e-06,4.528052127313271e-06,155 +dtmc,reducible-n0025-s02718,reducible,25,2718,finite-time/observation/k-100,2.4984650833681216e-05,3.907895706843177e-08,2.4955239737533943e-05,2.504153703642821e-05,2.4971509044849013e-05,2.4996231143134383e-05,120 +dtmc,reducible-n0025-s02718,reducible,25,2718,finite-time/step,7.996351332477634e-07,8.076610848756912e-09,7.931971028312177e-07,8.1824370679341e-07,7.978499828216931e-07,8.037806507127832e-07,189 +dtmc,reducible-n0025-s02718,reducible,25,2718,hitting-probability/cold-all-states,4.062852844348342e-05,7.281865233039607e-08,4.056855924955385e-05,4.0769041769460194e-05,4.058635882854819e-05,4.0677823697613484e-05,111 +dtmc,reducible-n0025-s02718,reducible,25,2718,hitting-probability/warm-lookup,2.4087435048772368e-08,4.660829905366855e-10,2.3668298005071434e-08,2.7688221830873018e-08,2.3911206052429504e-08,2.4428414226527892e-08,287 +dtmc,reducible-n0025-s02718,reducible,25,2718,hitting-time/cold-all-states,2.426803687093667e-05,7.226889020587448e-08,2.422781476078685e-05,2.4400865263338725e-05,2.4253508366294115e-05,2.4287318075565916e-05,120 +dtmc,reducible-n0025-s02718,reducible,25,2718,hitting-time/warm-lookup,2.402301968036652e-08,1.7690705084370587e-10,2.3867129727640274e-08,2.710179741547235e-08,2.3947105727536675e-08,2.417847232491618e-08,288 +dtmc,reducible-n0025-s02718,reducible,25,2718,hitting/bounded/at-most/k-10,4.356119981301683e-06,4.012629802118614e-08,4.326448417142839e-06,4.533697221423644e-06,4.345370383050881e-06,4.3711426937874375e-06,153 +dtmc,reducible-n0025-s02718,reducible,25,2718,hitting/bounded/at-most/k-100,2.5393158702116348e-05,1.5237010610025164e-07,2.5275075218498545e-05,2.5663084754071913e-05,2.5338231838153053e-05,2.548459087847732e-05,120 +dtmc,reducible-n0025-s02718,reducible,25,2718,hitting/bounded/exact/k-10,4.273336963816593e-06,1.762762062266226e-08,4.257739413949499e-06,4.298487813988079e-06,4.265643164890443e-06,4.276861422892891e-06,156 +dtmc,reducible-n0025-s02718,reducible,25,2718,hitting/bounded/exact/k-100,2.5231449399143457e-05,7.560837949658299e-08,2.5172195691225105e-05,2.537142884518419e-05,2.5201416671431314e-05,2.5267022429034115e-05,121 +dtmc,reducible-n0025-s02718,reducible,25,2718,hitting/bounded/greater-than/k-10,4.352857130431572e-06,7.152806085065466e-08,4.286449571798054e-06,4.445521026277794e-06,4.317134466240347e-06,4.391982722023647e-06,155 +dtmc,reducible-n0025-s02718,reducible,25,2718,hitting/bounded/greater-than/k-100,2.5634116183804973e-05,6.982708757706857e-08,2.557791292444413e-05,2.574940427947898e-05,2.5606340077678554e-05,2.5659390856795337e-05,121 +dtmc,reducible-n0025-s02718,reducible,25,2718,occupation-matrix,0.00017376236117316708,2.1979210719985176e-07,0.0001736038166528893,0.00017431869637221097,0.00017369021710085994,0.00017383814556524158,97 +dtmc,reducible-n0025-s02718,reducible,25,2718,power/10,1.6653764624144407e-05,7.794493166157272e-08,1.6587056350686306e-05,1.6876499492874636e-05,1.6643537116900154e-05,1.666950098876661e-05,153 +dtmc,reducible-n0025-s02718,reducible,25,2718,power/100,2.0191987633535237e-05,7.022205743196949e-08,2.014978854851115e-05,2.0321207468760634e-05,2.0179935003013176e-05,2.021714034969059e-05,150 +dtmc,reducible-n0025-s02718,reducible,25,2718,power/2,1.3328014471053647e-05,2.5676382249758365e-08,1.330595460220348e-05,1.3358348156197716e-05,1.3324149780942416e-05,1.3333513508424968e-05,158 +dtmc,reducible-n0025-s02718,reducible,25,2718,return/bounded/k-10,3.786775667011119e-06,1.774173564049788e-08,3.77405763795919e-06,3.817723496780751e-06,3.7826373980505208e-06,3.7914074512748383e-06,156 +dtmc,reducible-n0025-s02718,reducible,25,2718,return/bounded/k-100,2.5328116989644465e-05,4.798101758184026e-07,2.494296381233393e-05,2.6307891433437667e-05,2.5202871935272757e-05,2.5656978524243248e-05,118 +dtmc,reducible-n0025-s02718,reducible,25,2718,stationary,1.445047153927292e-05,5.124623024462208e-08,1.4411896408871215e-05,1.4544699826738526e-05,1.4437383800310996e-05,1.4490500193046914e-05,131 +dtmc,reducible-n0025-s02718,reducible,25,2718,structure/classes-cold,9.60475419430329e-06,1.5192242904377818e-08,9.588486263211516e-06,9.618667152146416e-06,9.600075594776349e-06,9.608420393088376e-06,139 +dtmc,reducible-n0025-s02718,reducible,25,2718,structure/classes-lifecycle,4.842639240896483e-05,1.7810973091275548e-07,4.829831269902806e-05,5.0987959195591625e-05,4.8351127247066994e-05,4.870139401473908e-05,132 +dtmc,reducible-n0025-s02718,reducible,25,2718,structure/classes-warm/access,8.628516499468044e-09,1.2571574892090003e-10,8.513628284964982e-09,1.089654102835847e-08,8.550473434153036e-09,8.72815631275034e-09,309 +dtmc,reducible-n0025-s02718,reducible,25,2718,structure/classes-warm/consumed,1.1328562572590982e-07,5.085436383133664e-10,1.1297427661559227e-07,1.1872548670007439e-07,1.1310545708307846e-07,1.1363827307884009e-07,256 +dtmc,reducible-n0025-s02718,reducible,25,2718,structure/irreducible-cold,7.3037234006109854e-06,1.6578116681988368e-08,7.284177902002572e-06,7.3190030109669485e-06,7.295155055111363e-06,7.306943586530182e-06,145 +dtmc,reducible-n0025-s02718,reducible,25,2718,structure/irreducible-warm,9.450094132524527e-09,1.4020809115429275e-10,9.31940604213751e-09,1.189908632392594e-08,9.388375915755387e-09,9.52962383301454e-09,307 +dtmc,reducible-n0025-s02718,reducible,25,2718,visits/bounded-expectation/k-10,6.505425049583675e-06,2.6313174345745086e-07,6.275129635469057e-06,6.876037962014317e-06,6.426613741841004e-06,6.617410052092066e-06,148 +dtmc,reducible-n0025-s02718,reducible,25,2718,visits/bounded-expectation/k-100,4.344735975791991e-05,8.862152978985732e-08,4.338487906352384e-05,4.368903067980653e-05,4.34211676702926e-05,4.350355525086913e-05,117 +dtmc,reducible-n0025-s31415,reducible,25,31415,construction/public-consumed,3.71209397722405e-05,6.116194675467011e-08,3.707288749761561e-05,3.7200955737926134e-05,3.71109480615678e-05,3.715080951917029e-05,137 +dtmc,reducible-n0025-s31415,reducible,25,31415,evolution/k-10,2.320729747182098e-06,7.966462212605973e-09,2.3144934736128334e-06,2.343787506253299e-06,2.3180230916578847e-06,2.323252513797354e-06,194 +dtmc,reducible-n0025-s31415,reducible,25,31415,evolution/k-100,8.689583331693475e-06,8.446965536763383e-08,8.608149304128461e-06,8.774991815485238e-06,8.677160198523003e-06,8.704584207009063e-06,167 +dtmc,reducible-n0025-s31415,reducible,25,31415,evolution/one-step,3.9556326625440075e-07,9.516316018276217e-09,3.8650056637534954e-07,4.099137682007748e-07,3.948398637713539e-07,3.970382261149815e-07,230 +dtmc,reducible-n0025-s31415,reducible,25,31415,finite-time/n-step/k-10,3.6970987757123725e-06,1.7883860243906497e-08,3.6835223159095136e-06,3.732710551392193e-06,3.6934121284460607e-06,3.7012395415359567e-06,158 +dtmc,reducible-n0025-s31415,reducible,25,31415,finite-time/n-step/k-100,2.4103287380978826e-05,5.096580119234334e-08,2.4052814610926856e-05,2.4153501984921252e-05,2.4094379289072335e-05,2.4119774518191123e-05,122 +dtmc,reducible-n0025-s31415,reducible,25,31415,finite-time/observation/k-10,4.473716470491983e-06,1.2516416377919556e-08,4.46249887202833e-06,4.4896666319497545e-06,4.470358423357593e-06,4.476204185596006e-06,155 +dtmc,reducible-n0025-s31415,reducible,25,31415,finite-time/observation/k-100,2.4817492683521574e-05,5.8181920192308017e-08,2.4771608877927065e-05,2.4999129167828027e-05,2.4798753599595255e-05,2.4861149017162848e-05,121 +dtmc,reducible-n0025-s31415,reducible,25,31415,finite-time/step,8.06811086849954e-07,4.158025973902218e-09,8.035100367456662e-07,8.117504044521488e-07,8.056280103017684e-07,8.078732881350098e-07,190 +dtmc,reducible-n0025-s31415,reducible,25,31415,hitting-probability/cold-all-states,4.096557981190213e-05,6.821813793958281e-08,4.091374882447876e-05,4.1087501449510456e-05,4.095071392152839e-05,4.098980571143329e-05,111 +dtmc,reducible-n0025-s31415,reducible,25,31415,hitting-probability/warm-lookup,2.4261049249553013e-08,6.4282960020209e-10,2.362705644746442e-08,2.6782668702861192e-08,2.419693035269714e-08,2.436293535280758e-08,288 +dtmc,reducible-n0025-s31415,reducible,25,31415,hitting-time/cold-all-states,2.4157497985167906e-05,2.527016237094153e-08,2.4135440813595246e-05,2.4193240773759326e-05,2.414872466023186e-05,2.416802939855565e-05,120 +dtmc,reducible-n0025-s31415,reducible,25,31415,hitting-time/warm-lookup,2.402022159247411e-08,1.5453781829831244e-10,2.3886531164056875e-08,2.767826457970607e-08,2.3937393678673778e-08,2.4182774468518368e-08,288 +dtmc,reducible-n0025-s31415,reducible,25,31415,hitting/bounded/at-most/k-10,4.280541011562141e-06,2.379931591333852e-08,4.261531024722599e-06,4.3219412673043745e-06,4.270589221072529e-06,4.286893979749746e-06,155 +dtmc,reducible-n0025-s31415,reducible,25,31415,hitting/bounded/at-most/k-100,2.519960980862379e-05,4.249820969577211e-08,2.516066888347268e-05,2.525905505292684e-05,2.5181982923170612e-05,2.5209399609593675e-05,121 +dtmc,reducible-n0025-s31415,reducible,25,31415,hitting/bounded/exact/k-10,4.202708829650517e-06,9.261926891185615e-09,4.194161543272052e-06,4.212308488258375e-06,4.200390737879886e-06,4.205660108812422e-06,156 +dtmc,reducible-n0025-s31415,reducible,25,31415,hitting/bounded/exact/k-100,2.5050138088102502e-05,3.8710094924293076e-08,2.502047242733203e-05,2.5118264841053208e-05,2.503908785689146e-05,2.506544153630823e-05,121 +dtmc,reducible-n0025-s31415,reducible,25,31415,hitting/bounded/greater-than/k-10,4.2927965785820225e-06,3.0883516186094745e-08,4.2690635478242955e-06,4.348717704322718e-06,4.280625447521473e-06,4.308291585037318e-06,156 +dtmc,reducible-n0025-s31415,reducible,25,31415,hitting/bounded/greater-than/k-100,2.55126396819465e-05,2.9327288859987225e-08,2.5491421471707124e-05,2.55741146651821e-05,2.55052660646424e-05,2.552047848492267e-05,121 +dtmc,reducible-n0025-s31415,reducible,25,31415,occupation-matrix,0.00017347316960948184,1.1613544234395558e-07,0.00017338796766498723,0.00017369153792969882,0.00017343741287974968,0.00017350114958264448,97 +dtmc,reducible-n0025-s31415,reducible,25,31415,power/10,1.631097290343092e-05,2.1849310377611403e-08,1.6294547024882413e-05,1.6372777982042285e-05,1.6305399985194252e-05,1.6316222316632654e-05,154 +dtmc,reducible-n0025-s31415,reducible,25,31415,power/100,2.002371603813383e-05,8.978597802624291e-08,1.9925277503918753e-05,2.009619997899827e-05,1.9985820155500645e-05,2.0039619830051274e-05,150 +dtmc,reducible-n0025-s31415,reducible,25,31415,power/2,1.3177405953312152e-05,1.3188827927051681e-08,1.3169075130317792e-05,1.3225235856629701e-05,1.3174683469405306e-05,1.3181249960325658e-05,158 +dtmc,reducible-n0025-s31415,reducible,25,31415,return/bounded/k-10,3.7246853311996113e-06,1.0604402337266532e-08,3.714938455625152e-06,3.738873639127677e-06,3.7224998372236646e-06,3.7287962555453396e-06,159 +dtmc,reducible-n0025-s31415,reducible,25,31415,return/bounded/k-100,2.470194102408221e-05,2.9449593912588104e-08,2.467490436848445e-05,2.4738440988585352e-05,2.4689433068550866e-05,2.4710741040835678e-05,121 +dtmc,reducible-n0025-s31415,reducible,25,31415,stationary,1.4398037849369462e-05,3.4550113039649865e-08,1.4366471751299333e-05,1.4448780877915978e-05,1.4386955537164295e-05,1.4407623076703453e-05,131 +dtmc,reducible-n0025-s31415,reducible,25,31415,structure/classes-cold,9.49977159810563e-06,2.8985711857298566e-08,9.472311707213521e-06,9.537716063537768e-06,9.492357755610267e-06,9.508755035560831e-06,137 +dtmc,reducible-n0025-s31415,reducible,25,31415,structure/classes-lifecycle,4.9658074054863564e-05,1.2170211836589313e-06,4.840699653347873e-05,5.037514682275258e-05,4.8488440479412074e-05,4.996792765603842e-05,132 +dtmc,reducible-n0025-s31415,reducible,25,31415,structure/classes-warm/access,8.586096110000972e-09,7.970594199004232e-11,8.517401842047717e-09,1.0775860489999084e-08,8.555399956649396e-09,8.656525813565532e-09,309 +dtmc,reducible-n0025-s31415,reducible,25,31415,structure/classes-warm/consumed,1.1334628105859795e-07,4.759946827175438e-10,1.1299431779510585e-07,1.2352075544150184e-07,1.1319596476458404e-07,1.1368816371925349e-07,256 +dtmc,reducible-n0025-s31415,reducible,25,31415,structure/irreducible-cold,7.234623338335009e-06,1.1548462011115243e-08,7.2253107328365726e-06,7.2560259335095365e-06,7.232629404973253e-06,7.238200334826989e-06,145 +dtmc,reducible-n0025-s31415,reducible,25,31415,structure/irreducible-warm,9.451749100945067e-09,1.3705446213858415e-10,9.329433331108143e-09,1.1846136443200412e-08,9.404787247560403e-09,9.532641567857282e-09,307 +dtmc,reducible-n0025-s31415,reducible,25,31415,visits/bounded-expectation/k-10,6.542272121902629e-06,2.2742234038657723e-07,6.149594711202253e-06,6.619062435863768e-06,6.343058739459806e-06,6.555658680889265e-06,148 +dtmc,reducible-n0025-s31415,reducible,25,31415,visits/bounded-expectation/k-100,4.352780605485249e-05,8.278448686739067e-08,4.34673593322193e-05,4.3972144856103924e-05,4.350901873449808e-05,4.357064808794271e-05,117 +dtmc,reducible-n0050-s01729,reducible,50,1729,construction/public-consumed,0.0001451437499781605,3.8472539123853315e-07,0.00014480807559183714,0.000146708357663426,0.00014496200981061432,0.00014559169940184802,109 +dtmc,reducible-n0050-s01729,reducible,50,1729,evolution/k-10,4.392436027384396e-06,1.3885421671235428e-08,4.384237207410127e-06,4.441778672536691e-06,4.389627877295386e-06,4.395820164623168e-06,180 +dtmc,reducible-n0050-s01729,reducible,50,1729,evolution/k-100,2.064827319690614e-05,1.2737009103161621e-07,2.0558358722570286e-05,2.1766291320091112e-05,2.0599733235849814e-05,2.084335763739594e-05,148 +dtmc,reducible-n0050-s01729,reducible,50,1729,evolution/one-step,7.48202627048243e-07,1.4266139875383886e-08,7.340430302467319e-07,7.676980158516971e-07,7.462565048152338e-07,7.503024056448691e-07,217 +dtmc,reducible-n0050-s01729,reducible,50,1729,finite-time/n-step/k-10,5.827928815199566e-06,1.2892012350822992e-07,5.709623548660911e-06,6.098710556124571e-06,5.742421552729143e-06,5.8994080759294835e-06,150 +dtmc,reducible-n0050-s01729,reducible,50,1729,finite-time/n-step/k-100,4.334938902747109e-05,9.646189111163194e-08,4.326003872940693e-05,4.3534665768895526e-05,4.331648872017705e-05,4.3389955118817106e-05,108 +dtmc,reducible-n0050-s01729,reducible,50,1729,finite-time/observation/k-10,7.165828876637755e-06,3.0749355912042696e-08,7.1455912851498785e-06,7.291447538797657e-06,7.158505791662521e-06,7.191704935394227e-06,144 +dtmc,reducible-n0050-s01729,reducible,50,1729,finite-time/observation/k-100,4.46904842865494e-05,6.404899120863363e-08,4.4640234439649524e-05,4.477439425319421e-05,4.467499847512001e-05,4.4725653466777607e-05,108 +dtmc,reducible-n0050-s01729,reducible,50,1729,finite-time/step,8.215841293083817e-07,6.1654921113023666e-09,8.1666739278998e-07,8.330106869056926e-07,8.204840888420916e-07,8.23129084892571e-07,187 +dtmc,reducible-n0050-s01729,reducible,50,1729,hitting-probability/cold-all-states,0.00010372269468422493,1.4763737830756013e-07,0.00010360093941876811,0.00010405821006591297,0.00010367309012032488,0.00010380213867884668,91 +dtmc,reducible-n0050-s01729,reducible,50,1729,hitting-probability/warm-lookup,2.3848983224697938e-08,2.504996596825827e-10,2.3654485557973187e-08,2.6898806035490197e-08,2.376921147116592e-08,2.3974465732819018e-08,288 +dtmc,reducible-n0050-s01729,reducible,50,1729,hitting-time/cold-all-states,6.430247988366598e-05,2.771325546417939e-07,6.408982541567335e-05,6.529988027297658e-05,6.422405379688305e-05,6.443326152730342e-05,100 +dtmc,reducible-n0050-s01729,reducible,50,1729,hitting-time/warm-lookup,2.404748627692809e-08,2.0994294019859042e-10,2.3868725255404844e-08,2.6945954665452953e-08,2.3967811880021975e-08,2.4142976407919343e-08,288 +dtmc,reducible-n0050-s01729,reducible,50,1729,hitting/bounded/at-most/k-10,7.599369358733707e-06,6.882720143700672e-08,7.543823749217345e-06,7.85341969980808e-06,7.577296955388816e-06,7.636522241227794e-06,144 +dtmc,reducible-n0050-s01729,reducible,50,1729,hitting/bounded/at-most/k-100,4.6463566374431335e-05,6.390323848979641e-08,4.6424017728828335e-05,4.662999114360602e-05,4.644576223459815e-05,4.6476716178544786e-05,107 +dtmc,reducible-n0050-s01729,reducible,50,1729,hitting/bounded/exact/k-10,7.489722286890455e-06,2.7799939823793607e-08,7.469562581254085e-06,7.558862444105948e-06,7.483611019173016e-06,7.499829676347871e-06,144 +dtmc,reducible-n0050-s01729,reducible,50,1729,hitting/bounded/exact/k-100,4.6480233369661976e-05,5.542691102789304e-08,4.643229420066356e-05,4.6594850563463853e-05,4.6461622597643526e-05,4.650846669694391e-05,106 +dtmc,reducible-n0050-s01729,reducible,50,1729,hitting/bounded/greater-than/k-10,7.581391802248559e-06,5.9071853553909e-08,7.548679261884202e-06,7.808886785577025e-06,7.572067698568549e-06,7.610109482431941e-06,144 +dtmc,reducible-n0050-s01729,reducible,50,1729,hitting/bounded/greater-than/k-100,4.653965798169995e-05,6.369626168170801e-08,4.647261155716458e-05,4.6578804455887165e-05,4.651222345591116e-05,4.654597687322517e-05,106 +dtmc,reducible-n0050-s01729,reducible,50,1729,occupation-matrix,0.0005957730292520805,4.987579934495633e-07,0.0005954065205736139,0.0005967766686495374,0.0005956182063374174,0.000596134752699624,72 +dtmc,reducible-n0050-s01729,reducible,50,1729,power/10,4.680869372700591e-05,9.78577526482322e-08,4.673046748847325e-05,4.7024255240000985e-05,4.677290700880383e-05,4.684902111438128e-05,132 +dtmc,reducible-n0050-s01729,reducible,50,1729,power/100,5.7254970197390353e-05,3.8905417847999644e-07,5.70122237818857e-05,5.7970297535082376e-05,5.7155361078125804e-05,5.742576530402792e-05,128 +dtmc,reducible-n0050-s01729,reducible,50,1729,power/2,4.0126395127138204e-05,3.7900024705909817e-08,4.0096722998136156e-05,4.0183607039182394e-05,4.011527769357365e-05,4.013508544446709e-05,136 +dtmc,reducible-n0050-s01729,reducible,50,1729,return/bounded/k-10,5.835114319661404e-06,1.8288253178816228e-08,5.8230793348026365e-06,5.8589075892607805e-06,5.830233097977696e-06,5.840268568135798e-06,149 +dtmc,reducible-n0050-s01729,reducible,50,1729,return/bounded/k-100,4.4647298716801825e-05,5.126055678491865e-08,4.4613685614618926e-05,4.47970353087899e-05,4.463105293477405e-05,4.4668211163100494e-05,108 +dtmc,reducible-n0050-s01729,reducible,50,1729,stationary,3.544159699231386e-05,5.967972893862917e-08,3.538428482518179e-05,3.550449753484201e-05,3.541793992263737e-05,3.5461521584470315e-05,113 +dtmc,reducible-n0050-s01729,reducible,50,1729,structure/classes-cold,2.578238324410877e-05,9.44254153583524e-08,2.5694460827234792e-05,2.5874061906634282e-05,2.5750746453400358e-05,2.582456164095821e-05,119 +dtmc,reducible-n0050-s01729,reducible,50,1729,structure/classes-lifecycle,0.0001870919917814544,8.393365822996664e-07,0.00018668787570277348,0.0001886665479044289,0.00018695636396503541,0.00018734743214524307,104 +dtmc,reducible-n0050-s01729,reducible,50,1729,structure/classes-warm/access,8.59683987886656e-09,9.568892499889176e-11,8.519653239258735e-09,1.0918670176831355e-08,8.551855745339748e-09,8.713757458774734e-09,309 +dtmc,reducible-n0050-s01729,reducible,50,1729,structure/classes-warm/consumed,2.3756353779052268e-07,6.659363649446419e-10,2.3711879724249682e-07,2.4396707120008374e-07,2.373956898490179e-07,2.3791011499183064e-07,241 +dtmc,reducible-n0050-s01729,reducible,50,1729,structure/irreducible-cold,2.151154865491755e-05,5.96970524975509e-08,2.1441334400329557e-05,2.1562681382225295e-05,2.1491431349810835e-05,2.1536020987025162e-05,123 +dtmc,reducible-n0050-s01729,reducible,50,1729,structure/irreducible-warm,9.39732874840154e-09,1.0678738746073993e-10,9.303728700271695e-09,1.182023191151427e-08,9.34869812711697e-09,9.494400105184896e-09,307 +dtmc,reducible-n0050-s01729,reducible,50,1729,visits/bounded-expectation/k-10,8.330669412417692e-06,3.6035009905543863e-08,8.30458066130175e-06,8.419077373970219e-06,8.321839864239922e-06,8.346322944849662e-06,142 +dtmc,reducible-n0050-s01729,reducible,50,1729,visits/bounded-expectation/k-100,6.399572644291831e-05,7.715852945750504e-08,6.393178082981477e-05,6.408222930522908e-05,6.397755408663272e-05,6.402169938139e-05,100 +dtmc,reducible-n0050-s02718,reducible,50,2718,construction/public-consumed,0.00014882411439867533,3.488381230627827e-06,0.0001459846580952504,0.00015310241020755373,0.00014768333348911256,0.00015080705174784126,109 +dtmc,reducible-n0050-s02718,reducible,50,2718,evolution/k-10,4.572255434114594e-06,1.7735493929634327e-07,4.401305525908545e-06,4.825366236868181e-06,4.480424675906315e-06,4.663289943596762e-06,180 +dtmc,reducible-n0050-s02718,reducible,50,2718,evolution/k-100,2.077159466395198e-05,2.2020091839405177e-07,2.060430937227775e-05,2.2583332489981935e-05,2.066946666066845e-05,2.0939834131341842e-05,147 +dtmc,reducible-n0050-s02718,reducible,50,2718,evolution/one-step,7.486905394103184e-07,1.4390024609178465e-08,7.341794940134071e-07,7.620289907295953e-07,7.393370303411403e-07,7.505623079534708e-07,218 +dtmc,reducible-n0050-s02718,reducible,50,2718,finite-time/n-step/k-10,5.752279321313836e-06,2.2336069948733713e-08,5.7364505513154045e-06,5.797711699934942e-06,5.7481601709119415e-06,5.7618022007417865e-06,149 +dtmc,reducible-n0050-s02718,reducible,50,2718,finite-time/n-step/k-100,4.328088454720727e-05,5.2836681814362165e-08,4.325167448510626e-05,4.335435458900724e-05,4.3266624728279696e-05,4.329939348815334e-05,108 +dtmc,reducible-n0050-s02718,reducible,50,2718,finite-time/observation/k-10,7.1631769130293e-06,1.4301962245711697e-08,7.149619417951296e-06,7.180546365109169e-06,7.158967410203527e-06,7.166996329378005e-06,145 +dtmc,reducible-n0050-s02718,reducible,50,2718,finite-time/observation/k-100,4.4657229844405935e-05,3.495332747231603e-08,4.462422038153031e-05,4.469738438915115e-05,4.464807077864715e-05,4.4669434982909e-05,108 +dtmc,reducible-n0050-s02718,reducible,50,2718,finite-time/step,8.296001975784034e-07,1.3982318514250763e-08,8.179698173091354e-07,8.550705513879705e-07,8.270020991789572e-07,8.353659190804635e-07,189 +dtmc,reducible-n0050-s02718,reducible,50,2718,hitting-probability/cold-all-states,0.00010419668048415584,1.4321858273707666e-07,0.00010408101052246352,0.00010446578067939603,0.00010415988568470859,0.00010425422588014043,90 +dtmc,reducible-n0050-s02718,reducible,50,2718,hitting-probability/warm-lookup,2.3756363065302856e-08,1.7712648939796768e-10,2.361491977663884e-08,2.7393276014840978e-08,2.3678106554032888e-08,2.402991828225017e-08,288 +dtmc,reducible-n0050-s02718,reducible,50,2718,hitting-time/cold-all-states,6.44293888601371e-05,5.135313138395365e-07,6.404784916741575e-05,6.839013106085131e-05,6.429981149267406e-05,6.492987876718942e-05,97 +dtmc,reducible-n0050-s02718,reducible,50,2718,hitting-time/warm-lookup,2.4550601796067823e-08,6.593985514172118e-10,2.3982175218722286e-08,2.9613539466589077e-08,2.4348253470472353e-08,2.4936633333953313e-08,286 +dtmc,reducible-n0050-s02718,reducible,50,2718,hitting/bounded/at-most/k-10,7.464000637359394e-06,9.322242460102434e-09,7.457456100014638e-06,7.47446090176561e-06,7.461999368771431e-06,7.466040252741366e-06,144 +dtmc,reducible-n0050-s02718,reducible,50,2718,hitting/bounded/at-most/k-100,4.635392767626237e-05,6.793325730551595e-08,4.6321337863996084e-05,4.650437098778481e-05,4.63405492457656e-05,4.639128011952673e-05,106 +dtmc,reducible-n0050-s02718,reducible,50,2718,hitting/bounded/exact/k-10,7.475505053362513e-06,1.7917137610937424e-08,7.45701546553897e-06,7.49190144628713e-06,7.468235276744169e-06,7.48000213442872e-06,144 +dtmc,reducible-n0050-s02718,reducible,50,2718,hitting/bounded/exact/k-100,4.642814325263211e-05,3.519797285283507e-08,4.6393631294319325e-05,4.646460896982901e-05,4.6411900744697186e-05,4.644057497154625e-05,107 +dtmc,reducible-n0050-s02718,reducible,50,2718,hitting/bounded/greater-than/k-10,7.5337387125530475e-06,2.25284957165377e-08,7.514524060410213e-06,7.563401859265158e-06,7.5269002484564685e-06,7.5399766044463746e-06,144 +dtmc,reducible-n0050-s02718,reducible,50,2718,hitting/bounded/greater-than/k-100,4.6889733512267145e-05,3.2266001094177516e-07,4.659176824792002e-05,4.7538106195447257e-05,4.676651547520628e-05,4.700304504334575e-05,107 +dtmc,reducible-n0050-s02718,reducible,50,2718,occupation-matrix,0.000597696473805999,3.5134449936414006e-06,0.0005946999556423786,0.000643505806876793,0.0005958637509482084,0.0006196848080435302,70 +dtmc,reducible-n0050-s02718,reducible,50,2718,power/10,4.680553554312256e-05,1.2783839540017004e-07,4.673606915995301e-05,4.765793239258123e-05,4.6780551176596656e-05,4.6861893204538704e-05,132 +dtmc,reducible-n0050-s02718,reducible,50,2718,power/100,5.632537219525493e-05,2.0036974773920594e-07,5.615085709515759e-05,5.6594010758578904e-05,5.6260934890680665e-05,5.636247246457485e-05,129 +dtmc,reducible-n0050-s02718,reducible,50,2718,power/2,4.0147328035549896e-05,6.157418779947801e-08,4.0095134889798483e-05,4.0283476177388665e-05,4.0125094414322395e-05,4.016436044670021e-05,135 +dtmc,reducible-n0050-s02718,reducible,50,2718,return/bounded/k-10,6.177307416995367e-06,3.1128211695986855e-07,5.920401834886723e-06,6.650122191171864e-06,6.102378104096427e-06,6.352778320464054e-06,146 +dtmc,reducible-n0050-s02718,reducible,50,2718,return/bounded/k-100,4.530731388041022e-05,6.42344553092988e-07,4.476243058713155e-05,4.681781883763963e-05,4.500552720598745e-05,4.595347248444644e-05,106 +dtmc,reducible-n0050-s02718,reducible,50,2718,stationary,3.567265654661848e-05,2.1146084923333574e-07,3.55454113661027e-05,3.611697816864937e-05,3.56429943959454e-05,3.5776637593732664e-05,113 +dtmc,reducible-n0050-s02718,reducible,50,2718,structure/classes-cold,2.572909945615031e-05,7.844114548854026e-08,2.5675391929764065e-05,2.630843463961574e-05,2.570279302880302e-05,2.5779058724320774e-05,118 +dtmc,reducible-n0050-s02718,reducible,50,2718,structure/classes-lifecycle,0.00018717468128695263,9.540051310114245e-07,0.00018640352786880815,0.0001890961251601333,0.00018688393699734852,0.0001878250006120652,104 +dtmc,reducible-n0050-s02718,reducible,50,2718,structure/classes-warm/access,9.06550166639175e-09,4.60493800718642e-10,8.716302188933275e-09,1.2404062614424322e-08,9.000658590281211e-09,9.227028955811826e-09,308 +dtmc,reducible-n0050-s02718,reducible,50,2718,structure/classes-warm/consumed,2.3856385996309653e-07,1.3128219266753185e-09,2.3750601553506612e-07,2.4591073324454235e-07,2.3819019314953377e-07,2.3941472749849577e-07,240 +dtmc,reducible-n0050-s02718,reducible,50,2718,structure/irreducible-cold,2.1613541651855815e-05,6.194150797421251e-08,2.1561407626307758e-05,2.1681831196525103e-05,2.160091166564022e-05,2.1632198013763114e-05,123 +dtmc,reducible-n0050-s02718,reducible,50,2718,structure/irreducible-warm,1.045791450655866e-08,1.0848369610618942e-09,9.488432768643063e-09,1.4625845431765211e-08,1.0236873882472301e-08,1.0720917149140021e-08,307 +dtmc,reducible-n0050-s02718,reducible,50,2718,visits/bounded-expectation/k-10,8.391433910123611e-06,6.909803824655497e-08,8.33857367310309e-06,8.652675508831939e-06,8.370455297817652e-06,8.418055695806624e-06,141 +dtmc,reducible-n0050-s02718,reducible,50,2718,visits/bounded-expectation/k-100,6.411631936481235e-05,1.313187980982064e-07,6.401436132497921e-05,6.437402073198533e-05,6.407278667849049e-05,6.417310132120967e-05,100 +dtmc,reducible-n0050-s31415,reducible,50,31415,construction/public-consumed,0.00014518628987665895,4.845397333503568e-07,0.00014483064484422005,0.00014658640942578484,0.00014506402435203046,0.00014550250901276785,109 +dtmc,reducible-n0050-s31415,reducible,50,31415,evolution/k-10,4.401717526937714e-06,2.0077361892330113e-08,4.38577450451351e-06,4.4478484359424026e-06,4.3955363292732965e-06,4.415485974667328e-06,181 +dtmc,reducible-n0050-s31415,reducible,50,31415,evolution/k-100,2.0985303549876404e-05,4.400719675357745e-07,2.0595125739796544e-05,2.1820723639776635e-05,2.078859338157431e-05,2.1162136461701214e-05,149 +dtmc,reducible-n0050-s31415,reducible,50,31415,evolution/one-step,7.703194960046907e-07,2.7552727510135013e-08,7.472235691315737e-07,8.071204240533334e-07,7.683683131625386e-07,7.741476689592343e-07,217 +dtmc,reducible-n0050-s31415,reducible,50,31415,finite-time/n-step/k-10,5.763638070605409e-06,5.7055261165190136e-08,5.716321832169929e-06,5.9093603317409945e-06,5.738906222585665e-06,5.796580074364894e-06,149 +dtmc,reducible-n0050-s31415,reducible,50,31415,finite-time/n-step/k-100,4.327767568891376e-05,7.235945059544003e-08,4.3218051222940154e-05,4.343560245541418e-05,4.324731463566918e-05,4.331432191676233e-05,108 +dtmc,reducible-n0050-s31415,reducible,50,31415,finite-time/observation/k-10,7.169721465079313e-06,2.608693611060778e-08,7.14930259467413e-06,7.1998435431001245e-06,7.160078333617241e-06,7.176112073163192e-06,145 +dtmc,reducible-n0050-s31415,reducible,50,31415,finite-time/observation/k-100,4.469914849114352e-05,5.331341546904115e-08,4.4652274943692886e-05,4.4780503416333496e-05,4.468174517117161e-05,4.472692009065733e-05,108 +dtmc,reducible-n0050-s31415,reducible,50,31415,finite-time/step,8.177978046898674e-07,9.213210579118132e-09,8.103376243975056e-07,8.31380020827055e-07,8.155374626557415e-07,8.199462114838476e-07,189 +dtmc,reducible-n0050-s31415,reducible,50,31415,hitting-probability/cold-all-states,0.00010407259777864619,2.8270987469713934e-07,0.00010383809964908188,0.00010458288064304118,0.0001039540877987817,0.00010419985929113483,90 +dtmc,reducible-n0050-s31415,reducible,50,31415,hitting-probability/warm-lookup,2.3762351499813596e-08,1.5945773709797212e-10,2.361586719083157e-08,2.6876371990950715e-08,2.3708582792005806e-08,2.4017640525184235e-08,288 +dtmc,reducible-n0050-s31415,reducible,50,31415,hitting-time/cold-all-states,6.423674352489818e-05,1.1542806863753835e-07,6.412286019301356e-05,6.435248972385737e-05,6.42122450904979e-05,6.42537655591293e-05,100 +dtmc,reducible-n0050-s31415,reducible,50,31415,hitting-time/warm-lookup,2.4066950660668365e-08,1.9447248897841724e-10,2.3893563277348595e-08,2.7187914903541762e-08,2.3961431500633255e-08,2.4264394370990324e-08,288 +dtmc,reducible-n0050-s31415,reducible,50,31415,hitting/bounded/at-most/k-10,7.529703453729944e-06,2.2133393177589854e-08,7.512511376040698e-06,7.564736922082877e-06,7.5237868416095595e-06,7.534522253019748e-06,144 +dtmc,reducible-n0050-s31415,reducible,50,31415,hitting/bounded/at-most/k-100,4.647816810378098e-05,7.095761513902513e-08,4.6421680335547374e-05,4.659159722336049e-05,4.646194388276195e-05,4.651058850991461e-05,107 +dtmc,reducible-n0050-s31415,reducible,50,31415,hitting/bounded/exact/k-10,7.470158789678632e-06,1.1339365983860287e-08,7.460371273607784e-06,7.48846896685491e-06,7.465724063088675e-06,7.472535168026161e-06,144 +dtmc,reducible-n0050-s31415,reducible,50,31415,hitting/bounded/exact/k-100,4.648085458905903e-05,8.736109660071462e-08,4.640709825838578e-05,4.658332360328509e-05,4.6451363507940464e-05,4.6516138561919595e-05,107 +dtmc,reducible-n0050-s31415,reducible,50,31415,hitting/bounded/greater-than/k-10,7.597946228606342e-06,6.912003137897718e-08,7.557217264763473e-06,8.278023460844215e-06,7.57708226750411e-06,7.937063197123508e-06,144 +dtmc,reducible-n0050-s31415,reducible,50,31415,hitting/bounded/greater-than/k-100,4.6654716632994155e-05,8.478058136737363e-08,4.657670362405313e-05,4.682269688520919e-05,4.661868725259624e-05,4.6683698238753905e-05,107 +dtmc,reducible-n0050-s31415,reducible,50,31415,occupation-matrix,0.0005959805710020359,7.956871089041654e-07,0.0005951525431980244,0.0005966238023105923,0.0005956316027291767,0.0005962325790022636,72 +dtmc,reducible-n0050-s31415,reducible,50,31415,power/10,4.822333346808591e-05,1.018104578092025e-06,4.729871340643587e-05,4.981948702685507e-05,4.783196661756832e-05,4.8467418631951535e-05,132 +dtmc,reducible-n0050-s31415,reducible,50,31415,power/100,5.765921378042549e-05,5.426630630846248e-07,5.733199447277124e-05,5.9636656028113746e-05,5.748849769240936e-05,5.7995182011332326e-05,127 +dtmc,reducible-n0050-s31415,reducible,50,31415,power/2,4.083673730330181e-05,5.059668180093381e-07,4.043743477662778e-05,4.2323503092678514e-05,4.064661165691226e-05,4.10811178257092e-05,134 +dtmc,reducible-n0050-s31415,reducible,50,31415,return/bounded/k-10,5.845744899303025e-06,2.1716290689846238e-08,5.826809029455861e-06,5.870372035004108e-06,5.842234054224864e-06,5.854478861995934e-06,149 +dtmc,reducible-n0050-s31415,reducible,50,31415,return/bounded/k-100,4.4649218731158876e-05,3.696074530195627e-08,4.461910543596765e-05,4.470609676999851e-05,4.463545602365312e-05,4.4663709039533774e-05,108 +dtmc,reducible-n0050-s31415,reducible,50,31415,stationary,3.5820594374557763e-05,3.6354068706536796e-07,3.557411343216131e-05,3.7054027403106315e-05,3.566089153869937e-05,3.636401171596455e-05,112 +dtmc,reducible-n0050-s31415,reducible,50,31415,structure/classes-cold,2.6236110392750965e-05,3.2094270018568494e-07,2.6032495305252895e-05,2.6627521756067758e-05,2.616510755615309e-05,2.638783823866188e-05,119 +dtmc,reducible-n0050-s31415,reducible,50,31415,structure/classes-lifecycle,0.0001888458090435539,1.41585436652837e-06,0.0001876753861627852,0.00019135240232097877,0.00018821254606735422,0.00018924537019942094,104 +dtmc,reducible-n0050-s31415,reducible,50,31415,structure/classes-warm/access,8.828001462706327e-09,2.5462688448175734e-10,8.616091480702308e-09,1.1075941604102337e-08,8.773798687153007e-09,8.956181466142732e-09,309 +dtmc,reducible-n0050-s31415,reducible,50,31415,structure/classes-warm/consumed,2.421468588182399e-07,3.1711218232963953e-09,2.3940724836858916e-07,2.483869580420423e-07,2.4150261324272194e-07,2.428808019923031e-07,240 +dtmc,reducible-n0050-s31415,reducible,50,31415,structure/irreducible-cold,2.1946076433070833e-05,3.2144094256903046e-07,2.1709344224128658e-05,2.269273837945158e-05,2.1839431647361418e-05,2.2186370762555224e-05,123 +dtmc,reducible-n0050-s31415,reducible,50,31415,structure/irreducible-warm,9.589521900125113e-09,2.6791595917953923e-10,9.332585957891873e-09,1.3032071361512183e-08,9.492645895700129e-09,9.708171108624251e-09,306 +dtmc,reducible-n0050-s31415,reducible,50,31415,visits/bounded-expectation/k-10,8.34705114010876e-06,3.14068186341636e-08,8.309334311821717e-06,8.372467563846468e-06,8.340834875986593e-06,8.354360576978716e-06,142 +dtmc,reducible-n0050-s31415,reducible,50,31415,visits/bounded-expectation/k-100,6.415507222191363e-05,1.3981286201134366e-07,6.406817502261234e-05,6.49009998596739e-05,6.411799161772555e-05,6.430599938279816e-05,100 +dtmc,reducible-n0100-s01729,reducible,100,1729,construction/public-consumed,0.0005851730770350863,1.214460314610138e-06,0.0005844978993991389,0.000586729961742591,0.000584982053820008,0.000585564814779597,81 +dtmc,reducible-n0100-s01729,reducible,100,1729,evolution/k-10,1.0120802393921676e-05,1.1677018010496953e-08,1.011097039672701e-05,1.0136640040186643e-05,1.0117038675270748e-05,1.012402941491825e-05,164 +dtmc,reducible-n0100-s01729,reducible,100,1729,evolution/k-100,9.493672613625306e-05,6.574279322852332e-08,9.487055261614809e-05,9.500043548316631e-05,9.492298756018188e-05,9.495354179760003e-05,118 +dtmc,reducible-n0100-s01729,reducible,100,1729,evolution/one-step,1.6064188847567467e-06,7.7112747900384e-09,1.6020163125894102e-06,1.6354973749479369e-06,1.6035935582291662e-06,1.612848194237376e-06,202 +dtmc,reducible-n0100-s01729,reducible,100,1729,finite-time/n-step/k-10,1.217984898510028e-05,1.1044780907480903e-07,1.2082799057295991e-05,1.2305088895983517e-05,1.215488448923559e-05,1.2210433176607362e-05,135 +dtmc,reducible-n0100-s01729,reducible,100,1729,finite-time/n-step/k-100,9.69794861688685e-05,8.960894962045684e-08,9.691058252262486e-05,9.722382308166764e-05,9.694302554152206e-05,9.701101939272783e-05,92 +dtmc,reducible-n0100-s01729,reducible,100,1729,finite-time/observation/k-10,1.4357043473429219e-05,3.5113409788042747e-08,1.432999769934764e-05,1.4416131497987103e-05,1.4348939915630713e-05,1.436745517350193e-05,131 +dtmc,reducible-n0100-s01729,reducible,100,1729,finite-time/observation/k-100,0.00010121131152845919,1.5649020170744644e-06,9.967353428954622e-05,0.000103578989532812,0.00010022165319558395,0.0001020453155173787,91 +dtmc,reducible-n0100-s01729,reducible,100,1729,finite-time/step,8.628414850917426e-07,1.0671702084999553e-08,8.54937481873264e-07,8.864158344051398e-07,8.611949070259593e-07,8.658137862923844e-07,186 +dtmc,reducible-n0100-s01729,reducible,100,1729,hitting-probability/cold-all-states,0.0003236544368767434,3.23704960433443e-07,0.00032341053344089806,0.0003241059265907525,0.0003235328168199031,0.00032394364609865953,67 +dtmc,reducible-n0100-s01729,reducible,100,1729,hitting-probability/warm-lookup,2.3812638585428486e-08,2.209623828906909e-10,2.360312346160774e-08,2.691947204536748e-08,2.368068632779865e-08,2.4080287305910912e-08,288 +dtmc,reducible-n0100-s01729,reducible,100,1729,hitting-time/cold-all-states,0.00020473411308018143,3.457718011160298e-07,0.00020445392012908613,0.0002051698509603739,0.00020464422414079309,0.00020479489310634553,77 +dtmc,reducible-n0100-s01729,reducible,100,1729,hitting-time/warm-lookup,2.4016527769811164e-08,1.6588790688009986e-10,2.3866037655103148e-08,2.7102703578691698e-08,2.3921992339060454e-08,2.4213656662796833e-08,288 +dtmc,reducible-n0100-s01729,reducible,100,1729,hitting/bounded/at-most/k-10,1.8810415385900343e-05,8.059449008477682e-08,1.872513695651343e-05,1.8883525542656165e-05,1.87950317957406e-05,1.8830472537793977e-05,126 +dtmc,reducible-n0100-s01729,reducible,100,1729,hitting/bounded/at-most/k-100,0.00010806980592543007,1.3267850576026869e-07,0.00010794611866563522,0.00010821404120018568,0.00010804413212070973,0.00010811562284631519,90 +dtmc,reducible-n0100-s01729,reducible,100,1729,hitting/bounded/exact/k-10,1.8494405834825655e-05,1.2235764469368946e-07,1.8395962587629372e-05,1.9119352124019875e-05,1.8444827142496214e-05,1.8559350218426985e-05,125 +dtmc,reducible-n0100-s01729,reducible,100,1729,hitting/bounded/exact/k-100,0.00010750794634796477,1.4787187147272742e-07,0.00010738985192186472,0.00010770372987405564,0.0001074728440933418,0.00010756037619990514,90 +dtmc,reducible-n0100-s01729,reducible,100,1729,hitting/bounded/greater-than/k-10,1.8812571510435204e-05,8.088685503529735e-08,1.873539937927586e-05,1.8896012174821694e-05,1.878017074967928e-05,1.8829997354473493e-05,126 +dtmc,reducible-n0100-s01729,reducible,100,1729,hitting/bounded/greater-than/k-100,0.00010729815582225769,2.597569664567392e-07,0.00010709787489932274,0.00010771692888573108,0.00010720833476322393,0.00010742528685416238,90 +dtmc,reducible-n0100-s01729,reducible,100,1729,occupation-matrix,0.0027718062465601975,6.804423815885826e-06,0.0027677181567601302,0.0027802713455457708,0.00277010840169775,0.0027769973205570924,46 +dtmc,reducible-n0100-s01729,reducible,100,1729,power/10,0.0001653197781800838,1.9877799608685213e-07,0.00016517100755461593,0.00016577552379076418,0.00016527631554421723,0.00016537012742182632,107 +dtmc,reducible-n0100-s01729,reducible,100,1729,power/100,0.00020734982720374773,3.8535774090302623e-07,0.00020704857779097686,0.00020811000838754756,0.00020724671048810706,0.00020747723803305696,102 +dtmc,reducible-n0100-s01729,reducible,100,1729,power/2,0.00013287583057787207,1.1651633573871536e-07,0.00013277411765558596,0.00013306923856879307,0.0001328399144097746,0.00013292206436275474,111 +dtmc,reducible-n0100-s01729,reducible,100,1729,return/bounded/k-10,1.2629370589921666e-05,7.197078874047263e-08,1.2565642849523274e-05,1.2712829601906167e-05,1.2608019408818975e-05,1.2648092178733544e-05,134 +dtmc,reducible-n0100-s01729,reducible,100,1729,return/bounded/k-100,0.0001008771505439654,1.2250179511115607e-07,0.00010076015387342269,0.00010101823082906723,0.00010082542864857094,0.0001009269836358726,91 +dtmc,reducible-n0100-s01729,reducible,100,1729,stationary,0.00011720711946668892,3.539785413316112e-07,0.0001168202401151055,0.00011755887035471988,0.00011707555119679353,0.00011734540118783551,88 +dtmc,reducible-n0100-s01729,reducible,100,1729,structure/classes-cold,8.909781571088537e-05,2.1502938864734233e-07,8.8880180877214e-05,8.930800221045355e-05,8.900447828382566e-05,8.91711350053535e-05,94 +dtmc,reducible-n0100-s01729,reducible,100,1729,structure/classes-lifecycle,0.0007936457044272185,2.9216039310564447e-06,0.0007848200077543462,0.0007957786744480648,0.0007924502552130583,0.0007945303414755206,75 +dtmc,reducible-n0100-s01729,reducible,100,1729,structure/classes-warm/access,8.574153490632675e-09,7.210806975490055e-11,8.510120904520359e-09,1.1017305198414573e-08,8.540699693404319e-09,8.649130594007376e-09,309 +dtmc,reducible-n0100-s01729,reducible,100,1729,structure/classes-warm/consumed,4.913403332816908e-07,1.565710627724612e-09,4.900606675958661e-07,5.004078701355503e-07,4.907199174023877e-07,4.922976401460643e-07,225 +dtmc,reducible-n0100-s01729,reducible,100,1729,structure/irreducible-cold,8.117025042670009e-05,2.528071160089594e-07,8.091180564641424e-05,8.142088881868403e-05,8.111437153089532e-05,8.12457109079609e-05,96 +dtmc,reducible-n0100-s01729,reducible,100,1729,structure/irreducible-warm,9.35689976986009e-09,6.329613241662295e-11,9.309302287288417e-09,1.1768318842523849e-08,9.334615419980907e-09,9.450545793415684e-09,307 +dtmc,reducible-n0100-s01729,reducible,100,1729,visits/bounded-expectation/k-10,1.5365152795789597e-05,6.431428455004975e-08,1.5288238462177064e-05,1.5423682213175137e-05,1.535033299607322e-05,1.537669413664844e-05,130 +dtmc,reducible-n0100-s01729,reducible,100,1729,visits/bounded-expectation/k-100,0.00012452695846368005,1.1188348944852372e-07,0.000124421203812138,0.0001246523846716537,0.00012447266878249744,0.0001245738554414062,87 +dtmc,reducible-n0100-s02718,reducible,100,2718,construction/public-consumed,0.0005851833351157807,8.866456334829468e-07,0.0005839854253281374,0.0005858578401746839,0.000585036928253806,0.0005854913522269717,81 +dtmc,reducible-n0100-s02718,reducible,100,2718,evolution/k-10,1.0135017322887254e-05,3.279062141642987e-08,1.0121038762082784e-05,1.0290011967897649e-05,1.012993907002922e-05,1.0142486514398894e-05,163 +dtmc,reducible-n0100-s02718,reducible,100,2718,evolution/k-100,0.00010009439825904515,2.185713777417834e-06,9.9832191664649e-05,0.0001024067820981145,9.995969621656097e-05,0.00010127050001709797,117 +dtmc,reducible-n0100-s02718,reducible,100,2718,evolution/one-step,1.6271107965679486e-06,2.159751217160973e-08,1.6072138105247574e-06,1.6630248865112662e-06,1.6175286853278055e-06,1.6324324344561712e-06,201 +dtmc,reducible-n0100-s02718,reducible,100,2718,finite-time/n-step/k-10,1.189580913188507e-05,3.365760117050776e-08,1.1872664767734094e-05,1.1953392458963208e-05,1.1887473846671351e-05,1.1914572314478677e-05,135 +dtmc,reducible-n0100-s02718,reducible,100,2718,finite-time/n-step/k-100,9.71281090762961e-05,3.0644538440855324e-07,9.679470262785624e-05,9.729035389246949e-05,9.702796757210752e-05,9.72258554690558e-05,92 +dtmc,reducible-n0100-s02718,reducible,100,2718,finite-time/observation/k-10,1.4400909543337349e-05,3.919122136240623e-08,1.4370962712620727e-05,1.446364217486678e-05,1.4392805319431724e-05,1.441519909386276e-05,131 +dtmc,reducible-n0100-s02718,reducible,100,2718,finite-time/observation/k-100,9.994576588117828e-05,1.1523761752135699e-07,9.984982433570011e-05,0.00010008657721009723,9.990357740411573e-05,9.998535097111017e-05,91 +dtmc,reducible-n0100-s02718,reducible,100,2718,finite-time/step,1.148788564596362e-06,1.1915548684996183e-07,9.160732280623459e-07,1.2410176590478725e-06,1.1182261858971751e-06,1.171030695681003e-06,188 +dtmc,reducible-n0100-s02718,reducible,100,2718,hitting-probability/cold-all-states,0.0003252593756769784,2.7260909767144303e-07,0.00032498736894040394,0.000325549376106614,0.00032508037660220737,0.0003253324471285289,67 +dtmc,reducible-n0100-s02718,reducible,100,2718,hitting-probability/warm-lookup,2.379807569976455e-08,2.421326340647012e-10,2.3603577625510748e-08,2.75552003203254e-08,2.3641235370543402e-08,2.413419702522237e-08,288 +dtmc,reducible-n0100-s02718,reducible,100,2718,hitting-time/cold-all-states,0.00020542619550034,3.3594335019422757e-07,0.00020513997385757928,0.000205839912020813,0.00020531285554170609,0.00020559868981332615,77 +dtmc,reducible-n0100-s02718,reducible,100,2718,hitting-time/warm-lookup,2.398926147713745e-08,1.4516348125385044e-10,2.3869325755180884e-08,2.7105557992832645e-08,2.392781059875022e-08,2.4093187004218713e-08,288 +dtmc,reducible-n0100-s02718,reducible,100,2718,hitting/bounded/at-most/k-10,1.8567255624061957e-05,7.16776425945033e-08,1.8522165729457816e-05,1.8992117818642738e-05,1.85436704972138e-05,1.8589614997976103e-05,123 +dtmc,reducible-n0100-s02718,reducible,100,2718,hitting/bounded/at-most/k-100,0.00010922124663015063,1.1434796918869801e-06,0.00010838134149375873,0.00011202589052436285,0.00010884368308926748,0.00011034782953439872,88 +dtmc,reducible-n0100-s02718,reducible,100,2718,hitting/bounded/exact/k-10,1.839819879411148e-05,3.607960340365967e-08,1.8364662716613976e-05,1.8440238978144947e-05,1.8389616573154173e-05,1.8412087698497118e-05,126 +dtmc,reducible-n0100-s02718,reducible,100,2718,hitting/bounded/exact/k-100,0.00010737836862566984,1.0892642219092064e-07,0.00010730660329489204,0.0001075588483993497,0.00010735303949853541,0.00010744497425876476,90 +dtmc,reducible-n0100-s02718,reducible,100,2718,hitting/bounded/greater-than/k-10,2.0078264510987732e-05,8.237724150080164e-07,1.9389282887504376e-05,2.1255456510501726e-05,1.990996294471165e-05,2.0422591151875113e-05,124 +dtmc,reducible-n0100-s02718,reducible,100,2718,hitting/bounded/greater-than/k-100,0.00010975000623147935,1.3832971746926604e-06,0.00010862652561627328,0.00011248916997103376,0.00010921147221434412,0.00011016250646207481,89 +dtmc,reducible-n0100-s02718,reducible,100,2718,occupation-matrix,0.0028325493609978976,2.318250615364662e-05,0.0028126486384800436,0.0028674820450386544,0.0028262197275497865,0.0028500461155393474,46 +dtmc,reducible-n0100-s02718,reducible,100,2718,power/10,0.00016544212956904193,1.2086854766585548e-07,0.00016534226512440774,0.00016560888476445913,0.000165398280201136,0.0001654783487825434,107 +dtmc,reducible-n0100-s02718,reducible,100,2718,power/100,0.000206873090267998,1.8021717222122089e-07,0.00020668985369127379,0.00020703611626210814,0.0002067982369274097,0.0002069234840543741,102 +dtmc,reducible-n0100-s02718,reducible,100,2718,power/2,0.00013332968774193432,2.5510786802159305e-07,0.00013315757772459878,0.00013521679906044196,0.00013321119835242056,0.00013387259399599355,111 +dtmc,reducible-n0100-s02718,reducible,100,2718,return/bounded/k-10,1.3031003140127938e-05,3.6779709230426454e-07,1.2679550987692529e-05,1.3438166935531187e-05,1.2938089072793284e-05,1.3151828455912279e-05,132 +dtmc,reducible-n0100-s02718,reducible,100,2718,return/bounded/k-100,0.0001022301830265573,1.0420234703081702e-06,0.00010152883952090918,0.00010381038556735866,0.00010192811743380796,0.00010264545880359741,91 +dtmc,reducible-n0100-s02718,reducible,100,2718,stationary,0.00011758572717163979,3.4118782667428047e-07,0.00011721135092697696,0.0001178936656164367,0.00011744186949878312,0.00011772584283968425,88 +dtmc,reducible-n0100-s02718,reducible,100,2718,structure/classes-cold,8.92941128223452e-05,2.0701685429175905e-07,8.90894714480707e-05,8.950012929146207e-05,8.918539465319517e-05,8.93779576429785e-05,94 +dtmc,reducible-n0100-s02718,reducible,100,2718,structure/classes-lifecycle,0.0007932949843557759,3.1521750680408743e-06,0.0007832267988746889,0.0007956120620300851,0.000790401610882125,0.0007945766735954547,75 +dtmc,reducible-n0100-s02718,reducible,100,2718,structure/classes-warm/access,8.650279342199053e-09,1.612299151492631e-10,8.501913395261846e-09,1.1014378089029557e-08,8.555661209377246e-09,8.838159614718285e-09,309 +dtmc,reducible-n0100-s02718,reducible,100,2718,structure/classes-warm/consumed,4.917422081480481e-07,2.3683073121139464e-09,4.897193413990683e-07,4.970832661496382e-07,4.910205504132386e-07,4.929671094764675e-07,226 +dtmc,reducible-n0100-s02718,reducible,100,2718,structure/irreducible-cold,8.1255935797648e-05,3.10800184845246e-07,8.093447658687918e-05,8.154815509737705e-05,8.114275017105061e-05,8.132721627381436e-05,96 +dtmc,reducible-n0100-s02718,reducible,100,2718,structure/irreducible-warm,9.358530762748848e-09,7.464380652756804e-11,9.297469772698442e-09,1.1643312630983783e-08,9.325300221440343e-09,9.438131518197018e-09,307 +dtmc,reducible-n0100-s02718,reducible,100,2718,visits/bounded-expectation/k-10,1.636977415859887e-05,6.447762357797341e-07,1.5751601084216626e-05,1.7033915243732152e-05,1.6192815678026784e-05,1.6474541737122482e-05,127 +dtmc,reducible-n0100-s02718,reducible,100,2718,visits/bounded-expectation/k-100,0.0001258747711812039,9.215078114121426e-07,0.00012524038137017685,0.00012709759456388657,0.0001255165658791617,0.0001263707713433123,87 +dtmc,reducible-n0100-s31415,reducible,100,31415,construction/public-consumed,0.0005946051429158875,6.82736503049015e-06,0.0005881106786286441,0.0006028773334239506,0.0005904062500727984,0.000597101247681209,81 +dtmc,reducible-n0100-s31415,reducible,100,31415,evolution/k-10,1.0245799785479903e-05,1.166605914985627e-07,1.0153627886682229e-05,1.0464655594244172e-05,1.0215355020560575e-05,1.0303191300679712e-05,163 +dtmc,reducible-n0100-s31415,reducible,100,31415,evolution/k-100,9.588320390321314e-05,6.91239602885964e-07,9.540778794374294e-05,9.704293995433768e-05,9.570830006850883e-05,9.61579037343224e-05,117 +dtmc,reducible-n0100-s31415,reducible,100,31415,evolution/one-step,1.6344167220051445e-06,2.701522595706081e-08,1.6086195743184622e-06,1.6645746654830873e-06,1.6292134624267563e-06,1.6377226630639698e-06,201 +dtmc,reducible-n0100-s31415,reducible,100,31415,finite-time/n-step/k-10,1.2053155301203598e-05,8.568709830175578e-08,1.198185317005835e-05,1.2151027086342627e-05,1.203931544281482e-05,1.2091254045091292e-05,135 +dtmc,reducible-n0100-s31415,reducible,100,31415,finite-time/n-step/k-100,9.730547739636428e-05,1.1278548052714657e-07,9.719808120385953e-05,9.751168021161103e-05,9.724093455472702e-05,9.733735875526786e-05,90 +dtmc,reducible-n0100-s31415,reducible,100,31415,finite-time/observation/k-10,1.4505197231553732e-05,4.8224752881000474e-08,1.4471108385568408e-05,1.4606287447217042e-05,1.4488790377961653e-05,1.4532164126670082e-05,130 +dtmc,reducible-n0100-s31415,reducible,100,31415,finite-time/observation/k-100,0.00010024414846806653,5.33633514322222e-07,9.984726978776356e-05,0.00010156786035069447,0.00010002114713449585,0.00010044108542691295,89 +dtmc,reducible-n0100-s31415,reducible,100,31415,finite-time/step,1.2298855660537015e-06,1.2663908675078512e-07,1.1159975192938071e-06,1.4000206330031852e-06,1.19273278760138e-06,1.268156338483095e-06,182 +dtmc,reducible-n0100-s31415,reducible,100,31415,hitting-probability/cold-all-states,0.0003349862524468759,5.825491690514685e-06,0.0003303102725919615,0.0003422702826516939,0.00033265448559066093,0.00033788463968614286,66 +dtmc,reducible-n0100-s31415,reducible,100,31415,hitting-probability/warm-lookup,2.4263996253665357e-08,5.779774512042762e-10,2.3837681203166625e-08,2.7813728968399053e-08,2.414848887167709e-08,2.4433039654703162e-08,288 +dtmc,reducible-n0100-s31415,reducible,100,31415,hitting-time/cold-all-states,0.00020642393750660903,1.2246964758856453e-06,0.0002053831222628315,0.00021104771442594547,0.00020586397802521548,0.00020718359883176163,76 +dtmc,reducible-n0100-s31415,reducible,100,31415,hitting-time/warm-lookup,2.457458110944175e-08,6.70892830158855e-10,2.3973245767741102e-08,2.7811075128066932e-08,2.4345896029696196e-08,2.4755110860781425e-08,287 +dtmc,reducible-n0100-s31415,reducible,100,31415,hitting/bounded/at-most/k-10,1.913564793607351e-05,3.3670706521479e-07,1.8814277852618893e-05,1.954462891448898e-05,1.9078615445033785e-05,1.9200019801194083e-05,124 +dtmc,reducible-n0100-s31415,reducible,100,31415,hitting/bounded/at-most/k-100,0.00010919375314475282,5.923219233457252e-07,0.00010876721098611597,0.0001102859367771695,0.00010908021983966507,0.00010961062105146246,89 +dtmc,reducible-n0100-s31415,reducible,100,31415,hitting/bounded/exact/k-10,1.8537500000093133e-05,8.280581771058664e-08,1.8475192771175828e-05,1.872621891316078e-05,1.8513885960500273e-05,1.8564960919320582e-05,125 +dtmc,reducible-n0100-s31415,reducible,100,31415,hitting/bounded/exact/k-100,0.00010761415729582337,2.2883588070377677e-07,0.0001074347446211078,0.00010829159145941958,0.00010752473853231557,0.00010781118312892927,89 +dtmc,reducible-n0100-s31415,reducible,100,31415,hitting/bounded/greater-than/k-10,2.0433846890471077e-05,1.168097293023745e-06,1.95775505580311e-05,2.2583510144613683e-05,1.9976438125013374e-05,2.111950113183509e-05,125 +dtmc,reducible-n0100-s31415,reducible,100,31415,hitting/bounded/greater-than/k-100,0.00010814485722221434,4.06420562698066e-07,0.00010786478300545149,0.00010887112373985716,0.00010799139893909644,0.00010839515310633276,87 +dtmc,reducible-n0100-s31415,reducible,100,31415,occupation-matrix,0.00287070385135902,4.7476315750938055e-05,0.0028231996139683447,0.0029161413617244266,0.0028405348397791386,0.002897726508212815,46 +dtmc,reducible-n0100-s31415,reducible,100,31415,power/10,0.00016767531070281227,1.5156413977675682e-06,0.00016641212645841373,0.00017093122583734896,0.00016716197372014367,0.00016847467859372337,106 +dtmc,reducible-n0100-s31415,reducible,100,31415,power/100,0.00021695302440967484,5.929746738608398e-06,0.0002117462731389837,0.0002247225453505631,0.00021513379450284595,0.0002193934337207141,101 +dtmc,reducible-n0100-s31415,reducible,100,31415,power/2,0.00013420040573108204,7.737977689346268e-07,0.00013355507187324552,0.00013637693541169397,0.0001337847497779876,0.00013467549984907788,111 +dtmc,reducible-n0100-s31415,reducible,100,31415,return/bounded/k-10,1.265841707311993e-05,2.587074342057759e-07,1.2500092479345732e-05,1.3253590862548567e-05,1.257590077682612e-05,1.2836454373767532e-05,133 +dtmc,reducible-n0100-s31415,reducible,100,31415,return/bounded/k-100,0.00010093524023369189,1.0929616742507938e-07,0.00010084480742180959,0.00010108879731724946,0.00010087159927934408,0.00010095969794252724,91 +dtmc,reducible-n0100-s31415,reducible,100,31415,stationary,0.00012040494200644187,1.451404604555355e-06,0.00011909822590346042,0.00012248347506987802,0.00011963025463046506,0.0001209449616726488,87 +dtmc,reducible-n0100-s31415,reducible,100,31415,structure/classes-cold,8.982539148920356e-05,6.305078348137915e-07,8.939691944856589e-05,9.070497517049023e-05,8.962122603517139e-05,9.004104609658074e-05,93 +dtmc,reducible-n0100-s31415,reducible,100,31415,structure/classes-lifecycle,0.0008086866356678544,1.452899663547286e-05,0.0007970363714412087,0.0008258866506914064,0.0008020639734178598,0.0008160071146514847,74 +dtmc,reducible-n0100-s31415,reducible,100,31415,structure/classes-warm/access,9.078977729063678e-09,5.367509333543593e-10,8.591606229155038e-09,1.1434135210916367e-08,8.827332440330685e-09,9.213844012664395e-09,308 +dtmc,reducible-n0100-s31415,reducible,100,31415,structure/classes-warm/consumed,4.948184394563365e-07,4.636503927642096e-09,4.912974332058449e-07,5.088487259027633e-07,4.937723129915338e-07,4.981690468244181e-07,225 +dtmc,reducible-n0100-s31415,reducible,100,31415,structure/irreducible-cold,8.220668423746247e-05,7.31431860471297e-07,8.164952526255677e-05,8.657973750294851e-05,8.194126014929418e-05,8.25331661175808e-05,95 +dtmc,reducible-n0100-s31415,reducible,100,31415,structure/irreducible-warm,9.53960735020341e-09,2.326781805143457e-10,9.353599973803333e-09,1.1643312630983783e-08,9.488381020576483e-09,9.63272052790124e-09,307 +dtmc,reducible-n0100-s31415,reducible,100,31415,visits/bounded-expectation/k-10,1.5141324353166798e-05,6.44977862955139e-08,1.5078926350854869e-05,1.5211776279065074e-05,1.5117904357001611e-05,1.5157467714743689e-05,129 +dtmc,reducible-n0100-s31415,reducible,100,31415,visits/bounded-expectation/k-100,0.0001246274035476801,2.0955054294384545e-07,0.0001244358238808708,0.00012493926472444266,0.00012458234223931169,0.00012468449042026637,87 +dtmc,reducible-n0250-s01729,reducible,250,1729,construction/public-consumed,0.005203459134588998,3.6275024637001316e-05,0.0051638969668884715,0.0052359887510039825,0.005181997628799822,0.005227946329610329,40 +dtmc,reducible-n0250-s01729,reducible,250,1729,evolution/k-10,7.58858147525677e-05,8.573818593953636e-08,7.584033016327002e-05,7.604302429768892e-05,7.586526582726708e-05,7.593817127840802e-05,123 +dtmc,reducible-n0250-s01729,reducible,250,1729,evolution/k-100,0.0007435119328982312,4.7366137594160966e-07,0.0007431584088411232,0.000745489065746954,0.0007432828647286037,0.0007437932451020596,76 +dtmc,reducible-n0250-s01729,reducible,250,1729,evolution/one-step,9.067161465132297e-06,2.3114990216425596e-08,9.048932578588525e-06,9.142821331606569e-06,9.059465412256724e-06,9.079995601234781e-06,166 +dtmc,reducible-n0250-s01729,reducible,250,1729,hitting-probability/cold-all-states,0.0022629449583379735,9.303548722527921e-06,0.0022570119426548944,0.0022748879657535927,0.0022590085188858213,0.0022703793317001937,30 +dtmc,reducible-n0250-s01729,reducible,250,1729,hitting-probability/warm-lookup,2.3788582243830962e-08,1.9246554723254617e-10,2.3619197737880494e-08,2.737545077518948e-08,2.369747155877946e-08,2.398901000537027e-08,288 +dtmc,reducible-n0250-s01729,reducible,250,1729,hitting-time/cold-all-states,0.0016793765600942564,4.455733874590001e-06,0.0016752987010512893,0.001685110237899194,0.0016765701911936048,0.0016813499193435396,34 +dtmc,reducible-n0250-s01729,reducible,250,1729,hitting-time/warm-lookup,2.4077139143453767e-08,1.952108261105835e-10,2.3896588995786385e-08,2.744251722208017e-08,2.4003466079994056e-08,2.4254644772802586e-08,288 +dtmc,reducible-n0250-s01729,reducible,250,1729,occupation-matrix,0.02042899035344211,8.309296858247453e-05,0.020385720312983073,0.02053489164399462,0.02039286912544672,0.020514614550197683,18 +dtmc,reducible-n0250-s01729,reducible,250,1729,power/10,0.0011470610554961966,1.6751291003033806e-05,0.001125955263743986,0.00115965794963995,0.0011340837306283318,0.0011532862075470753,68 +dtmc,reducible-n0250-s01729,reducible,250,1729,power/100,0.001609594218240565,1.7423385018617817e-05,0.0015915818564410853,0.0016259866890873166,0.0016009049660793055,0.0016210505251365247,61 +dtmc,reducible-n0250-s01729,reducible,250,1729,power/2,0.0008166406250414806,1.6867402895545647e-05,0.0007996359334317266,0.0008313200761135497,0.000811280499958942,0.0008197207777508689,75 +dtmc,reducible-n0250-s01729,reducible,250,1729,stationary,0.0007321207133140795,9.1374123177561e-06,0.0007249100612091792,0.0007446901651922401,0.0007279261414493833,0.000739629466677018,51 +dtmc,reducible-n0250-s01729,reducible,250,1729,structure/classes-cold,0.00055798154504513,4.895484241429276e-06,0.000554322225599701,0.0005644226626567876,0.000555801794667566,0.0005604166389358314,56 +dtmc,reducible-n0250-s01729,reducible,250,1729,structure/classes-lifecycle,0.007304189888398266,4.8994540332979e-05,0.007262621878357039,0.007371753740136185,0.007270907894340589,0.007352485000155866,35 +dtmc,reducible-n0250-s01729,reducible,250,1729,structure/classes-warm/access,8.637714989281001e-09,1.2368863131252337e-10,8.52588460288118e-09,1.0775860489999084e-08,8.594124869749945e-09,8.726440135252636e-09,309 +dtmc,reducible-n0250-s01729,reducible,250,1729,structure/classes-warm/consumed,1.268935454707522e-06,1.1533636896658866e-08,1.259591202263164e-06,1.290108554277812e-06,1.266144948968292e-06,1.2722964435931945e-06,206 +dtmc,reducible-n0250-s01729,reducible,250,1729,structure/irreducible-cold,0.0005356128552063767,4.777298835549702e-06,0.0005314833004376851,0.0005409084706722449,0.0005332679346403373,0.0005387250583485833,57 +dtmc,reducible-n0250-s01729,reducible,250,1729,structure/irreducible-warm,9.439171749945392e-09,1.332309439091005e-10,9.330459687758459e-09,1.1741053901784036e-08,9.393669688864639e-09,9.557776404963552e-09,307 +dtmc,reducible-n0250-s02718,reducible,250,2718,construction/public-consumed,0.005194451453030754,3.107400483540494e-05,0.005137071387863668,0.005217306168076668,0.005162306249581484,0.005210472148531155,40 +dtmc,reducible-n0250-s02718,reducible,250,2718,evolution/k-10,7.585477536573557e-05,6.162777480815554e-08,7.57989588352286e-05,7.594706652785784e-05,7.584430802255935e-05,7.58815533594563e-05,123 +dtmc,reducible-n0250-s02718,reducible,250,2718,evolution/k-100,0.0007434012677192953,4.6532910972721256e-07,0.0007430023570249227,0.0007439511130063405,0.0007431845241669743,0.0007434867569419477,76 +dtmc,reducible-n0250-s02718,reducible,250,2718,evolution/one-step,9.0599404033639e-06,1.0424615161613855e-08,9.053755096802911e-06,9.104900416204689e-06,9.057733898131955e-06,9.063483160930906e-06,166 +dtmc,reducible-n0250-s02718,reducible,250,2718,hitting-probability/cold-all-states,0.0022667332561564094,5.416730760898899e-06,0.002262911414159351,0.0022727833296108477,0.0022637124789754706,0.0022716007624088283,30 +dtmc,reducible-n0250-s02718,reducible,250,2718,hitting-probability/warm-lookup,2.385678896309522e-08,2.4797504515291794e-10,2.3619402450670157e-08,2.708363265891097e-08,2.374559063827386e-08,2.4004906010707372e-08,288 +dtmc,reducible-n0250-s02718,reducible,250,2718,hitting-time/cold-all-states,0.0016852424130775034,7.663323103965984e-06,0.0016773034641148349,0.0016919817592549538,0.0016788284551195478,0.0016885959019418803,34 +dtmc,reducible-n0250-s02718,reducible,250,2718,hitting-time/warm-lookup,2.412931375409891e-08,2.551200726276719e-10,2.389138806696381e-08,2.7257732601940664e-08,2.3970973001243297e-08,2.4316050171935718e-08,288 +dtmc,reducible-n0250-s02718,reducible,250,2718,occupation-matrix,0.020443543264466117,4.693947974172136e-05,0.020405269337061327,0.020491283119554282,0.020405445182404947,0.02049048274420784,18 +dtmc,reducible-n0250-s02718,reducible,250,2718,power/10,0.0012465445000667717,0.0001023350070148935,0.0011484919661770756,0.0014008882670425763,0.0011524619564980917,0.0013049421935237102,67 +dtmc,reducible-n0250-s02718,reducible,250,2718,power/100,0.0015979398855982163,1.489311698397609e-05,0.0015827535318478228,0.0016124359928020883,0.0015890136613355328,0.0016050217014304104,61 +dtmc,reducible-n0250-s02718,reducible,250,2718,power/2,0.0008150530168763307,1.4334046149584007e-05,0.000797272891167859,0.0008210327211608482,0.0008094433816380884,0.0008185008122961955,74 +dtmc,reducible-n0250-s02718,reducible,250,2718,stationary,0.0007324114994844422,1.0227162015831329e-05,0.0007239713763049098,0.0007449433261338341,0.0007298238476953254,0.0007361805830788356,51 +dtmc,reducible-n0250-s02718,reducible,250,2718,structure/classes-cold,0.0005562608128849545,4.718760195559027e-06,0.0005510139062206182,0.0005603367626656914,0.0005539591642660928,0.0005582594442077809,56 +dtmc,reducible-n0250-s02718,reducible,250,2718,structure/classes-lifecycle,0.007238889001503897,3.704905388427458e-05,0.00720901993773887,0.0072879563465666364,0.007215041667222977,0.007272500001514952,35 +dtmc,reducible-n0250-s02718,reducible,250,2718,structure/classes-warm/access,8.634124853962371e-09,1.2378650563673601e-10,8.52147194164137e-09,1.1075941604102337e-08,8.568456816800273e-09,8.727762804067873e-09,309 +dtmc,reducible-n0250-s02718,reducible,250,2718,structure/classes-warm/consumed,1.2576852623465796e-06,2.315712182263696e-09,1.2563815589138958e-06,1.267687369226226e-06,1.2568657585057141e-06,1.2591761264528305e-06,207 +dtmc,reducible-n0250-s02718,reducible,250,2718,structure/irreducible-cold,0.0005320381817661903,4.209862302311396e-06,0.0005288856202876935,0.0005393980804671484,0.0005302306185699745,0.0005345205818327965,57 +dtmc,reducible-n0250-s02718,reducible,250,2718,structure/irreducible-warm,9.41787882596117e-09,1.0819383980634209e-10,9.325289218318446e-09,1.173959034709153e-08,9.378796469529616e-09,9.53117127497973e-09,307 +dtmc,reducible-n0250-s31415,reducible,250,31415,construction/public-consumed,0.005242275256387074,3.532033704807839e-05,0.0051834345447808764,0.00527568046480675,0.005217356676990731,0.005258318000031929,40 +dtmc,reducible-n0250-s31415,reducible,250,31415,evolution/k-10,7.584838911295972e-05,8.405581596158832e-08,7.577427345191126e-05,7.59650369193287e-05,7.582447755960377e-05,7.586652111428473e-05,123 +dtmc,reducible-n0250-s31415,reducible,250,31415,evolution/k-100,0.0007437913400701259,6.007112090082589e-07,0.0007432244872751081,0.0007446165982268675,0.0007435557331335442,0.0007440806823849146,76 +dtmc,reducible-n0250-s31415,reducible,250,31415,evolution/one-step,9.068875252421457e-06,1.310898205083352e-08,9.058380758190568e-06,9.1431901071776e-06,9.064344874558158e-06,9.07860545290483e-06,166 +dtmc,reducible-n0250-s31415,reducible,250,31415,hitting-probability/cold-all-states,0.0022683703286532617,5.294641347544822e-06,0.0022647664663264337,0.0022771538095437346,0.002265779732938446,0.0022736649700008066,30 +dtmc,reducible-n0250-s31415,reducible,250,31415,hitting-probability/warm-lookup,2.5492359184689902e-08,1.8672741428641147e-09,2.3649846240024127e-08,2.9849328089290564e-08,2.5044463537141895e-08,2.6011842353680838e-08,288 +dtmc,reducible-n0250-s31415,reducible,250,31415,hitting-time/cold-all-states,0.0016844320183274307,5.492242827551423e-06,0.001678667609823832,0.0016868988811508572,0.0016795633593574167,0.0016864245404907374,34 +dtmc,reducible-n0250-s31415,reducible,250,31415,hitting-time/warm-lookup,2.42029379199787e-08,3.2940327506737544e-10,2.3895816613385677e-08,2.7626245126309997e-08,2.4025167399546926e-08,2.4381759871587445e-08,288 +dtmc,reducible-n0250-s31415,reducible,250,31415,occupation-matrix,0.021723479250795208,0.0012004376694676466,0.02061747918924084,0.02351133298361674,0.02061747918924084,0.02351133298361674,17 +dtmc,reducible-n0250-s31415,reducible,250,31415,power/10,0.0011498008906427356,1.965125439443963e-05,0.0011331799740683561,0.001179566851836474,0.0011445430674448902,0.0011609969073173557,67 +dtmc,reducible-n0250-s31415,reducible,250,31415,power/100,0.001620617763870137,2.1534359580578557e-05,0.001604621499912658,0.0016594352232964917,0.0016099097216889884,0.0016317828463238233,61 +dtmc,reducible-n0250-s31415,reducible,250,31415,power/2,0.0008192266974028347,1.3312404854565695e-05,0.0008117146388502551,0.0008336469149820685,0.0008169838337279442,0.0008221687108458604,75 +dtmc,reducible-n0250-s31415,reducible,250,31415,stationary,0.0007292594091268256,6.96188005365494e-06,0.000725110695995643,0.0007429003663837542,0.0007268870363727079,0.0007346918049734086,51 +dtmc,reducible-n0250-s31415,reducible,250,31415,structure/classes-cold,0.0005562713437463912,4.541072107089067e-06,0.000552946691181364,0.0005617357065465386,0.0005549141654879448,0.0005584322812778521,56 +dtmc,reducible-n0250-s31415,reducible,250,31415,structure/classes-lifecycle,0.007334505060553607,5.388843919258701e-05,0.0072878525743058226,0.0073893321557787,0.0073096060461301186,0.0073577870369061,35 +dtmc,reducible-n0250-s31415,reducible,250,31415,structure/classes-warm/access,9.343664939236546e-09,4.996891733748475e-10,9.076919738389927e-09,1.1921700381909508e-08,9.241715894948036e-09,9.460598335696968e-09,309 +dtmc,reducible-n0250-s31415,reducible,250,31415,structure/classes-warm/consumed,1.2579699723772663e-06,2.253650824016272e-09,1.256361118633862e-06,1.26877559870038e-06,1.2572950772707889e-06,1.2597304669691734e-06,207 +dtmc,reducible-n0250-s31415,reducible,250,31415,structure/irreducible-cold,0.000533737097262369,4.381185364534944e-06,0.0005298244671264131,0.0005425580311566591,0.0005320692208543834,0.0005367084058757493,57 +dtmc,reducible-n0250-s31415,reducible,250,31415,structure/irreducible-warm,9.545850858551924e-09,2.206365657001394e-10,9.356574704803025e-09,1.2087022450903356e-08,9.468997873684994e-09,9.667459848456651e-09,307 +dtmc,reducible-n0500-s01729,reducible,500,1729,construction/public-consumed,0.028834515751066013,0.0003849952909149579,0.028523925809297777,0.02928613955691617,0.02863449532189753,0.029272112121361715,18 +dtmc,reducible-n0500-s01729,reducible,500,1729,evolution/k-10,0.00029719294285240146,3.1943578615453933e-07,0.0002967694671640761,0.00029735938086931457,0.00029706249915761873,0.00029725624996129995,95 +dtmc,reducible-n0500-s01729,reducible,500,1729,evolution/k-100,0.0029424054011377102,3.5182615961049015e-06,0.0029393366905144202,0.002946493472425007,0.0029407090825814457,0.002943647461226926,50 +dtmc,reducible-n0500-s01729,reducible,500,1729,evolution/one-step,3.282564437271965e-05,2.4307795599546364e-08,3.280499790805143e-05,3.289118176882767e-05,3.2812515226138795e-05,3.2841662687133066e-05,140 +dtmc,reducible-n0500-s01729,reducible,500,1729,hitting-probability/cold-all-states,0.014292323001427576,0.0017675323339062746,0.012532585903682048,0.015891416684098658,0.012524790667521301,0.016084166618384188,12 +dtmc,reducible-n0500-s01729,reducible,500,1729,hitting-probability/warm-lookup,2.3888911473285447e-08,2.859679820740347e-10,2.3619633064100305e-08,2.728367746809355e-08,2.3753214292599263e-08,2.4134774933055666e-08,288 +dtmc,reducible-n0500-s01729,reducible,500,1729,hitting-time/cold-all-states,0.010360087278159982,0.0001640996453513956,0.010164028497196602,0.010452792862755208,0.01015984833135181,0.010452872351985814,12 +dtmc,reducible-n0500-s01729,reducible,500,1729,hitting-time/warm-lookup,2.404170182737114e-08,1.7424758896212502e-10,2.3887106272273627e-08,2.7552014590257376e-08,2.3961974483969994e-08,2.42466949217288e-08,288 +dtmc,reducible-n0500-s01729,reducible,500,1729,power/10,0.006716684748817264,9.51246269048139e-05,0.006663488604153416,0.006823485652785167,0.00669275116632451,0.006780267256683493,36 +dtmc,reducible-n0500-s01729,reducible,500,1729,power/100,0.011131836100442645,0.00010807856659604542,0.011028882591000927,0.0112439246541516,0.011044133737940635,0.01121800754547373,29 +dtmc,reducible-n0500-s01729,reducible,500,1729,power/2,0.004199289966588063,7.955255880785555e-05,0.004131558498014337,0.0042912587035909035,0.004150920454941859,0.004240588068734558,44 +dtmc,reducible-n0500-s01729,reducible,500,1729,stationary,0.003367196286230215,4.4860985612363725e-05,0.0033271011918605794,0.0034584167466770546,0.003333837501122616,0.0034481250040698797,21 +dtmc,reducible-n0500-s01729,reducible,500,1729,structure/classes-cold,0.002620809565996751,2.3346453627499757e-05,0.0025974631123692514,0.0026378219137603246,0.0026009423322864763,0.0026306801689012596,25 +dtmc,reducible-n0500-s01729,reducible,500,1729,structure/classes-lifecycle,0.03915235766665622,0.0002785788224756308,0.038886322722268794,0.03951138635202369,0.038898866600357,0.03943040820304304,15 +dtmc,reducible-n0500-s01729,reducible,500,1729,structure/classes-warm/access,8.623527886778989e-09,1.0991747935712796e-10,8.521023393244758e-09,1.0918670176831355e-08,8.587697080456523e-09,8.70492001427948e-09,309 +dtmc,reducible-n0500-s01729,reducible,500,1729,structure/classes-warm/consumed,2.5348572079332113e-06,2.8724536769480197e-09,2.532604085442845e-06,2.55259832171076e-06,2.5335436071365153e-06,2.5361537485448945e-06,192 +dtmc,reducible-n0500-s01729,reducible,500,1729,structure/irreducible-cold,0.002520085824861391,3.674337005765975e-05,0.0024932479041776135,0.0025737778354227676,0.0024962499931765105,0.002557507427963248,26 +dtmc,reducible-n0500-s01729,reducible,500,1729,structure/irreducible-warm,9.726390641544201e-09,4.058477980667018e-10,9.330333439441363e-09,1.2663259267098146e-08,9.62576332429086e-09,9.8071296024624e-09,307 +dtmc,reducible-n0500-s02718,reducible,500,2718,construction/public-consumed,0.028555302660808794,0.00021748974540969357,0.028341605771017315,0.02874860126976273,0.0283625865396551,0.028741598046326543,18 +dtmc,reducible-n0500-s02718,reducible,500,2718,evolution/k-10,0.00029791436688011064,4.739035523079185e-07,0.0002972431055719753,0.0002982159615129507,0.00029769602023359195,0.00029800954851250735,95 +dtmc,reducible-n0500-s02718,reducible,500,2718,evolution/k-100,0.0029489368463867065,1.7214148177306134e-06,0.0029474455947750425,0.0029510084939530527,0.002947988526605011,0.002949592105180368,50 +dtmc,reducible-n0500-s02718,reducible,500,2718,evolution/one-step,3.260576635054445e-05,2.4326888155600847e-08,3.25923176064393e-05,3.269909919487686e-05,3.260058821352309e-05,3.261596467391745e-05,140 +dtmc,reducible-n0500-s02718,reducible,500,2718,hitting-probability/cold-all-states,0.014622906690490638,0.002145441401373389,0.011493569364877962,0.015745330987556372,0.011485388854149885,0.01595775548776146,12 +dtmc,reducible-n0500-s02718,reducible,500,2718,hitting-probability/warm-lookup,2.3981064594482254e-08,3.773411942495829e-10,2.3643419739464898e-08,2.723611690390069e-08,2.3797067245533295e-08,2.441224592099853e-08,288 +dtmc,reducible-n0500-s02718,reducible,500,2718,hitting-time/cold-all-states,0.010164838373384555,6.552853822843884e-05,0.010113924060351564,0.010362634895760232,0.01011327170781442,0.010380620783377838,12 +dtmc,reducible-n0500-s02718,reducible,500,2718,hitting-time/warm-lookup,2.408943842683821e-08,2.0245431038246663e-10,2.390279279779113e-08,2.7342692911778425e-08,2.398755274012996e-08,2.4224115104911492e-08,288 +dtmc,reducible-n0500-s02718,reducible,500,2718,power/10,0.0066267450815376515,8.810093780854157e-05,0.006541376440769194,0.006696264663045,0.006579996680375189,0.0066743184579977285,36 +dtmc,reducible-n0500-s02718,reducible,500,2718,power/100,0.011011744399244587,9.277938502020092e-05,0.010941636100566636,0.011124761365036566,0.010971870000939816,0.011091653225688083,29 +dtmc,reducible-n0500-s02718,reducible,500,2718,power/2,0.004226573863971597,0.00017210577849744065,0.0041228272326659,0.00465795427681817,0.004163511211048059,0.004511189152253792,43 +dtmc,reducible-n0500-s02718,reducible,500,2718,stationary,0.003388041671132669,3.615831956267331e-05,0.0033573782286391808,0.0034241999906953423,0.0033672576299233533,0.003421458328375593,21 +dtmc,reducible-n0500-s02718,reducible,500,2718,structure/classes-cold,0.0026068710458708837,2.4712647289214934e-05,0.002576276857455793,0.0026198701939742584,0.0025764344193573508,0.00261872899136506,25 +dtmc,reducible-n0500-s02718,reducible,500,2718,structure/classes-lifecycle,0.03875130566302687,0.00026579866243992,0.03852457816780468,0.03902719483218486,0.03848550700058695,0.03917844799798331,15 +dtmc,reducible-n0500-s02718,reducible,500,2718,structure/classes-warm/access,8.794280185610575e-09,2.7176160339685275e-10,8.532233600383049e-09,1.1295179067830364e-08,8.681906064536667e-09,8.875472175936332e-09,309 +dtmc,reducible-n0500-s02718,reducible,500,2718,structure/classes-warm/consumed,2.5391093148253757e-06,3.895056170148313e-09,2.5359278494281784e-06,2.5516200121418234e-06,2.5373737058984706e-06,2.5409734401706802e-06,192 +dtmc,reducible-n0500-s02718,reducible,500,2718,structure/irreducible-cold,0.002543554297881201,3.557470516257332e-05,0.0025363939110486008,0.002596187492599711,0.0025364633693243377,0.0025804192500800127,25 +dtmc,reducible-n0500-s02718,reducible,500,2718,structure/irreducible-warm,9.641397448028819e-09,3.07739681164836e-10,9.349605722659865e-09,1.2196389188791551e-08,9.510318554470145e-09,9.737660262323832e-09,307 +dtmc,reducible-n0500-s31415,reducible,500,31415,construction/public-consumed,0.02880335504402562,0.00021815626043664507,0.028513606501551943,0.028982353660627697,0.028563169916673188,0.028970742646111724,18 +dtmc,reducible-n0500-s31415,reducible,500,31415,evolution/k-10,0.0003015778262864102,3.393248548943118e-06,0.0002975403894867524,0.00030437549222071846,0.00029951089244195477,0.000302777805197171,94 +dtmc,reducible-n0500-s31415,reducible,500,31415,evolution/k-100,0.0029495806182239905,1.647230717011488e-06,0.002948232723600051,0.002951261416629201,0.0029488022336278978,0.002950047335989698,50 +dtmc,reducible-n0500-s31415,reducible,500,31415,evolution/one-step,3.271326773512374e-05,3.541172443622057e-08,3.268746675925044e-05,3.276976051085933e-05,3.270833431521342e-05,3.272892859078013e-05,140 +dtmc,reducible-n0500-s31415,reducible,500,31415,hitting-probability/cold-all-states,0.013845348826483434,0.0017432625802581286,0.012029068515017349,0.015066546524943238,0.012016568842778779,0.015092730051874819,12 +dtmc,reducible-n0500-s31415,reducible,500,31415,hitting-probability/warm-lookup,2.384017734111833e-08,2.2283791668961395e-10,2.3632629336477977e-08,2.7228167636154487e-08,2.3766542180619856e-08,2.3961971960725717e-08,288 +dtmc,reducible-n0500-s31415,reducible,500,31415,hitting-time/cold-all-states,0.01011254509979732,5.634059925796464e-05,0.010069522068079095,0.010178796653538788,0.010064794473388854,0.010189572824553277,12 +dtmc,reducible-n0500-s31415,reducible,500,31415,hitting-time/warm-lookup,2.4094507198172775e-08,2.0367552787467688e-10,2.3903874715558435e-08,2.7321023056407485e-08,2.3996334619442698e-08,2.4264680337597508e-08,288 +dtmc,reducible-n0500-s31415,reducible,500,31415,power/10,0.006784629312827166,0.00012129474000867379,0.006693750146043339,0.007437770622345852,0.006734264880790198,0.00685734696594159,36 +dtmc,reducible-n0500-s31415,reducible,500,31415,power/100,0.01111519441716761,0.00012134724480953804,0.010995302631176616,0.011236541661977148,0.011036527833008828,0.011211895851010923,29 +dtmc,reducible-n0500-s31415,reducible,500,31415,power/2,0.004148674917002944,7.659869739157915e-05,0.004088879912227707,0.004238281339022083,0.004123493010614441,0.004206976031655945,44 +dtmc,reducible-n0500-s31415,reducible,500,31415,stationary,0.0033417084237693678,2.8210946246482512e-05,0.0032934791306615807,0.00334844308831221,0.0032960833341348916,0.00334660398948472,21 +dtmc,reducible-n0500-s31415,reducible,500,31415,structure/classes-cold,0.002597728116476598,1.5021029288287769e-05,0.0025803328941722834,0.002610484537469277,0.0025827138327286143,0.0026074772083283715,26 +dtmc,reducible-n0500-s31415,reducible,500,31415,structure/classes-lifecycle,0.03894516964334928,0.0004001418121680131,0.038665902834812485,0.039424358058917836,0.0387813056683323,0.039380155270919204,15 +dtmc,reducible-n0500-s31415,reducible,500,31415,structure/classes-warm/access,8.606814816772089e-09,9.405707523069269e-11,8.52904691209182e-09,1.0893697550670169e-08,8.577147672342973e-09,8.68796019455416e-09,309 +dtmc,reducible-n0500-s31415,reducible,500,31415,structure/classes-warm/consumed,2.537817988714957e-06,4.6554804984763535e-09,2.5342003948634723e-06,2.549398384678463e-06,2.5364712804025907e-06,2.5401586328273883e-06,192 +dtmc,reducible-n0500-s31415,reducible,500,31415,structure/irreducible-cold,0.0025519753732494016,2.116914332700166e-05,0.002538946131178157,0.0025797413803384153,0.002543109844819727,0.002570070548158366,26 +dtmc,reducible-n0500-s31415,reducible,500,31415,structure/irreducible-warm,9.512217853051468e-09,1.8221271501144004e-10,9.34494937568119e-09,1.1987061830815841e-08,9.444531399843305e-09,9.632428133278234e-09,307 +dtmc,reducible-n1000-s01729,reducible,1000,1729,construction/public-consumed,0.13115561116622604,0.0015354854741807256,0.1297743835415791,0.13288109490713396,0.12960819042720167,0.13348689550184645,8 +dtmc,reducible-n1000-s01729,reducible,1000,1729,evolution/k-10,0.0019705953441746327,2.729991537947377e-06,0.001968284905014892,0.001973896384166474,0.001969666505787928,0.001972416631123247,58 +dtmc,reducible-n1000-s01729,reducible,1000,1729,evolution/k-100,0.019624676931540085,1.5693409391285412e-05,0.01961028535527201,0.01966261365582579,0.01961309044729096,0.019649320647364393,22 +dtmc,reducible-n1000-s01729,reducible,1000,1729,evolution/one-step,0.0002060252255767239,5.726871161647952e-07,0.00020546192797077923,0.000206588644252445,0.00020586561263575423,0.00020623427133738888,102 +dtmc,reducible-n1000-s01729,reducible,1000,1729,structure/classes-cold,0.027658442508254666,0.0007665772582792357,0.026992644251004096,0.029376802005572245,0.02689186524997543,0.03009736450136794,6 +dtmc,reducible-n1000-s01729,reducible,1000,1729,structure/classes-lifecycle,0.1992480104187659,0.002047959328774593,0.19834650272908524,0.2014861135947285,0.19213080737608834,0.20297476669948084,6 +dtmc,reducible-n1000-s01729,reducible,1000,1729,structure/classes-warm/access,8.644577477967186e-09,1.2472644817298214e-10,8.533482949980267e-09,1.0918670176831355e-08,8.583429154420041e-09,8.726016254202123e-09,309 +dtmc,reducible-n1000-s01729,reducible,1000,1729,structure/classes-warm/consumed,5.0965043203009184e-06,7.413327968405446e-09,5.090553859328955e-06,5.116672915998303e-06,5.0949261804346946e-06,5.09836267439454e-06,178 +dtmc,reducible-n1000-s01729,reducible,1000,1729,structure/irreducible-cold,0.026345075133819288,0.0001823435898889638,0.026296480517703457,0.026571229166923633,0.026077510749018984,0.0270832603321954,6 +dtmc,reducible-n1000-s01729,reducible,1000,1729,structure/irreducible-warm,9.492425286990571e-09,1.7038621571328328e-10,9.334072445172697e-09,1.1895986524079178e-08,9.433728846344585e-09,9.634821700474296e-09,307 +dtmc,reducible-n1000-s02718,reducible,1000,2718,construction/public-consumed,0.1309606041686493,0.0016526248728041537,0.12979178718731937,0.13294070430947613,0.12956579175079241,0.13314969274870236,8 +dtmc,reducible-n1000-s02718,reducible,1000,2718,evolution/k-10,0.0019528699814290503,2.1372362071353773e-06,0.0019506830955006286,0.001954874513344736,0.0019520699436979076,0.0019539672360729633,58 +dtmc,reducible-n1000-s02718,reducible,1000,2718,evolution/k-100,0.01944678053608892,1.1194312632531803e-05,0.01943520111187051,0.019455887964987165,0.01943635644662815,0.019454038920103382,22 +dtmc,reducible-n1000-s02718,reducible,1000,2718,evolution/one-step,0.00020250264086070288,3.30694442688133e-07,0.00020206240919475076,0.00020274294346049992,0.00020241304351340818,0.0002025906487549335,103 +dtmc,reducible-n1000-s02718,reducible,1000,2718,structure/classes-cold,0.0269785157458197,0.00026389029565810664,0.02677404742935323,0.02721520849566635,0.02640838721417822,0.027445183998982735,6 +dtmc,reducible-n1000-s02718,reducible,1000,2718,structure/classes-lifecycle,0.19970206600070622,0.00398490275013802,0.19324465023673837,0.2016384826686893,0.18811769160238329,0.20368696875084424,6 +dtmc,reducible-n1000-s02718,reducible,1000,2718,structure/classes-warm/access,8.650877427674308e-09,1.2610193608333223e-10,8.536042726377294e-09,1.0943040251731873e-08,8.600847275636324e-09,8.747914495197996e-09,309 +dtmc,reducible-n1000-s02718,reducible,1000,2718,structure/classes-warm/consumed,5.0953805558908655e-06,5.379705899178785e-09,5.091680159428374e-06,5.109538071539848e-06,5.093624757835788e-06,5.0975829543202605e-06,178 +dtmc,reducible-n1000-s02718,reducible,1000,2718,structure/irreducible-cold,0.026234368115547115,0.00020918070246504251,0.026056006898215855,0.026391573093133048,0.025909250125550898,0.02700129508108754,6 +dtmc,reducible-n1000-s02718,reducible,1000,2718,structure/irreducible-warm,9.477381670312685e-09,1.4650580893425625e-10,9.343041565828719e-09,1.1955135624911451e-08,9.396721888798244e-09,9.612735687171027e-09,307 +dtmc,reducible-n1000-s31415,reducible,1000,31415,construction/public-consumed,0.13164107037482609,0.0015865069193144732,0.13002833633592153,0.13305414582767602,0.12990276185779034,0.13324320833392753,8 +dtmc,reducible-n1000-s31415,reducible,1000,31415,evolution/k-10,0.001973974818733265,2.0039819802017845e-06,0.001972582551106679,0.0019767574947912423,0.00197314114860582,0.0019749145503737964,58 +dtmc,reducible-n1000-s31415,reducible,1000,31415,evolution/k-100,0.019617397611808782,1.2679888055167413e-05,0.019602881611684678,0.019623985561338486,0.019604717723753613,0.019621979965138182,22 +dtmc,reducible-n1000-s31415,reducible,1000,31415,evolution/one-step,0.00020614530637368814,6.132559325640032e-07,0.00020564447436988828,0.00020702827262409433,0.00020602318601943312,0.0002063023552859348,102 +dtmc,reducible-n1000-s31415,reducible,1000,31415,structure/classes-cold,0.028442864866519812,0.0014848030172288414,0.027123364561703056,0.0307532397491741,0.02695806184929097,0.04055824667254152,6 +dtmc,reducible-n1000-s31415,reducible,1000,31415,structure/classes-lifecycle,0.1984132084180601,0.0037708083924371805,0.19536113460975077,0.2011253194893167,0.19055747285019606,0.20427067186756176,6 +dtmc,reducible-n1000-s31415,reducible,1000,31415,structure/classes-warm/access,8.651362747287087e-09,1.3087220029824686e-10,8.530764655471261e-09,1.0943040251731873e-08,8.590169007550206e-09,8.747228492001535e-09,309 +dtmc,reducible-n1000-s31415,reducible,1000,31415,structure/classes-warm/consumed,5.096204027017615e-06,9.799994827303088e-09,5.0887430181894525e-06,5.132514955235704e-06,5.0919224289531e-06,5.101419580114699e-06,178 +dtmc,reducible-n1000-s31415,reducible,1000,31415,structure/irreducible-cold,0.026355405418629137,0.0002786094191833399,0.026184113585865514,0.026619800004118586,0.025973890755267348,0.02715161442029057,6 +dtmc,reducible-n1000-s31415,reducible,1000,31415,structure/irreducible-warm,9.434524731905023e-09,1.0984707111574956e-10,9.34092253933736e-09,1.1762480307794115e-08,9.398647347647496e-09,9.555175296738632e-09,307 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,absorption-time,0.00016700000560376793,2.4375112843699753e-06,0.00016493748989887536,0.00017171874787891284,0.00016533349844394252,0.0001697710031294264,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,absorption/probabilities,0.00017577050311956555,3.5205011954531074e-06,0.00017226099589606747,0.0001791875001799781,0.0001732500022626482,0.00017833350284490734,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,construction/public-consumed,0.00037158349732635543,2.812506863847375e-06,0.0003690207486215513,0.0003745832509594038,0.000369396002497524,0.0003741250038729049,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,evolution/k-10,5.158349813427776e-05,8.12498910818249e-07,5.081275594420731e-05,5.281249832478352e-05,5.09375095134601e-05,5.204150511417538e-05,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,evolution/k-100,0.00025766650651348755,1.8335049389861524e-06,0.0002563337475294247,0.0002607392452773638,0.00025710294175951276,0.0002598586816020543,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,evolution/one-step,2.96039943350479e-05,5.624970071949065e-07,2.9301747417775914e-05,3.106300573563203e-05,2.9374998121056706e-05,3.0062496080063283e-05,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,finite-time/n-step/k-10,4.975000047124922e-05,7.079943316057324e-07,4.917724436381832e-05,5.0624501454876736e-05,4.933300078846514e-05,5.0166010623797774e-05,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,finite-time/n-step/k-100,0.00026031250308733433,2.3749962565489113e-06,0.00025586525589460507,0.0002617289974296,0.0002578750063548796,0.0002613539982121438,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,finite-time/observation/k-10,5.0457994802854955e-05,1.0829971870407462e-06,4.934348908136599e-05,5.1229249947937205e-05,4.939599602948874e-05,5.075000808574259e-05,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,finite-time/observation/k-100,0.00026054149930132553,2.562999725341797e-06,0.00025810399165493436,0.0002632392533996608,0.00025945900415536016,0.0002623330074129626,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,finite-time/step,8.749993867240846e-07,8.299684850499034e-08,8.022507245186716e-07,9.477589628659189e-07,8.33999365568161e-07,9.169962140731514e-07,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,fundamental-matrix,0.00016483350191265345,2.7709902497008443e-06,0.00016290600615320727,0.00016816674906294793,0.0001634585059946403,0.00016716699610697106,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,hitting-probability/cold-all-states,4.383300256449729e-05,8.955030352808535e-07,4.3135245505254716e-05,4.542674287222326e-05,4.325000918470323e-05,4.460400668904185e-05,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,hitting-time/cold-all-states,9.04789922060445e-05,1.3119934010319412e-06,8.9728750026552e-05,9.365675578010269e-05,8.98750004125759e-05,9.258349746232852e-05,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,hitting/bounded/at-most/k-10,4.412449197843671e-05,6.034897523932159e-07,4.3666241253959015e-05,4.519774665823206e-05,4.375050775706768e-05,4.45835103164427e-05,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,hitting/bounded/at-most/k-100,0.00034054149000439793,3.250504960305989e-06,0.0003382082541065756,0.0003441462577029597,0.0003383959992788732,0.0003437919949647039,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,hitting/bounded/exact/k-10,4.252049984643236e-05,4.1649764170870185e-07,4.2135499825235456e-05,4.328075374360196e-05,4.231299681123346e-05,4.2958505218848586e-05,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,hitting/bounded/exact/k-100,0.00034629149740794674,1.0916002793237567e-05,0.0003367812532815151,0.0003649895006674342,0.00033993437318713404,0.00035697950079338625,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,hitting/bounded/greater-than/k-10,4.445800732355565e-05,3.335007932037115e-07,4.399975296109915e-05,4.473975423024967e-05,4.425000224728137e-05,4.4666499888990074e-05,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,hitting/bounded/greater-than/k-100,0.0003443329987931065,1.2294985936023295e-06,0.0003426772491366137,0.00034519774999353103,0.00034318749385420233,0.0003450209987931885,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,occupation-matrix,0.0008626034978078678,5.500500265043229e-06,0.0008544787451683078,0.0008668747504998464,0.0008579491524869808,0.0008662920008646324,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,power/10,0.0003126044975942932,2.4379914975725114e-06,0.00031047899756231345,0.00031551075153402053,0.0003106880030827597,0.00031447949731955305,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,power/100,0.00031670850148657337,1.5210025594569743e-06,0.0003156045058858581,0.0003188642549503129,0.00031574947279295885,0.00031766649772180244,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,power/2,0.00030977050482761115,1.9370054360479116e-06,0.0003078127483604476,0.0003115207400696818,0.000308229005895555,0.00031085399677976966,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,return/bounded/k-10,4.337500286055729e-05,7.499984349124134e-07,4.2729003325803205e-05,4.4218752009328455e-05,4.295799590181559e-05,4.4020998757332563e-05,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,return/bounded/k-100,0.0003341249903314747,2.2500098566524684e-06,0.00033199975223396905,0.00033637500018812716,0.00033281249488936737,0.0003359375041327439,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,stationary,0.00010054149606730789,1.7495040083304048e-06,9.92499990388751e-05,0.0001031042484100908,9.952150867320597e-05,0.00010233301145490259,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,structure/classes-cold,2.9270500817801803e-05,8.749993867240846e-07,2.830224548233673e-05,2.98332488455344e-05,2.845849667210132e-05,2.970799687318504e-05,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,structure/classes-lifecycle,0.00043608299165498465,3.311994078103453e-06,0.0004334482437116094,0.00044116600111010484,0.0004337499995017424,0.00043924999772571027,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,structure/classes-warm/access,2.1716249975725077e-07,5.624999175779528e-10,2.1678125049220396e-07,2.4002077479963193e-07,2.1683954983018338e-07,2.2850210007163697e-07,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,structure/classes-warm/consumed,9.931666500051506e-07,4.893749428447297e-09,9.892687248793664e-07,9.983239495340968e-07,9.904395992634817e-07,9.958353999536486e-07,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,structure/irreducible-cold,2.9666494810953736e-05,6.665068212896585e-07,2.893750206567347e-05,3.027050115633756e-05,2.9228988205431963e-05,3.0020499252714217e-05,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,structure/irreducible-warm,2.237624503322877e-07,7.562004611827396e-10,2.2319579984468875e-07,2.419468499283539e-07,2.2351670049829408e-07,2.334417004021816e-07,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,visits/bounded-expectation/k-10,1.9958504708483815e-05,3.9600126910954714e-07,1.9604747649282217e-05,2.0541250705718994e-05,1.9708502804860473e-05,2.010448952205479e-05,30 +pydtmc,absorbing-n0010-s01729,absorbing,10,1729,visits/bounded-expectation/k-100,7.856301090214401e-05,4.999965312890708e-07,7.80830014264211e-05,7.90622470958624e-05,7.829199603293091e-05,7.889599510235712e-05,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,absorption-time,0.00017124999430961907,8.10399797046557e-06,0.0001674687555350829,0.0001878437542472966,0.00016887242818484083,0.00018147899390896782,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,absorption/probabilities,0.00017502050468465313,3.5205084714107215e-06,0.00017292700431426056,0.00018097875363309868,0.00017370850400766358,0.00017841649969341233,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,construction/public-consumed,0.00037137549952603877,2.2294989321380854e-06,0.0003697812426253222,0.000376062496798113,0.00037029149825684726,0.0003734579950105399,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,evolution/k-10,5.1687493396457285e-05,4.789908416569233e-07,5.138549749972299e-05,5.304149817675352e-05,5.152049561729655e-05,5.235399294178933e-05,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,evolution/k-100,0.0002592705059214495,2.0410079741850495e-06,0.00025817724963417277,0.0002627294925332535,0.0002584169997135177,0.0002615624980535358,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,evolution/one-step,2.9812988941557705e-05,5.834954208694398e-07,2.9385504603851587e-05,3.102050686720759e-05,2.9520502721425146e-05,3.054100670851767e-05,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,finite-time/n-step/k-10,4.9875001423060894e-05,6.249974831007421e-07,4.9510250391904265e-05,5.080199844087474e-05,4.960398855473613e-05,5.0646005547605455e-05,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,finite-time/n-step/k-100,0.0002638125006342307,1.5210098354145885e-06,0.0002567707451817114,0.0002643437546794303,0.00025950049894163385,0.00026422950031701475,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,finite-time/observation/k-10,4.995849303668365e-05,7.920025382190943e-07,4.928125781589188e-05,5.086475721327588e-05,4.9542009946890175e-05,5.041699478169903e-05,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,finite-time/observation/k-100,0.00025725000159582123,2.5835033738985658e-06,0.0002556140025262721,0.00026102100673597306,0.0002564169990364462,0.00025995849136961624,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,finite-time/step,8.749993867240846e-07,4.149478627368808e-08,8.442475518677384e-07,9.170034900307655e-07,8.749921107664704e-07,9.165014489553869e-07,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,fundamental-matrix,0.00016243750724243,1.937500201165676e-06,0.0001612914929864928,0.00016796875206637196,0.0001614994980627671,0.00016627099830657244,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,hitting-probability/cold-all-states,4.39790019299835e-05,1.0625008144415915e-06,4.3176500184927136e-05,4.5698503527091816e-05,4.333397591835819e-05,4.470899875741452e-05,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,hitting-time/cold-all-states,9.247900015907362e-05,2.2914973669685423e-06,9.050999506143853e-05,9.500025407760404e-05,9.10419985302724e-05,9.416908269486156e-05,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,hitting/bounded/at-most/k-10,4.4145999709144235e-05,5.004985723644495e-07,4.3687745346687734e-05,4.4927488488610834e-05,4.383350460557267e-05,4.45414989371784e-05,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,hitting/bounded/at-most/k-100,0.00033966649789363146,2.1255036699585617e-06,0.00033777125645428896,0.00034462525218259543,0.0003381454953341745,0.00034215068626508577,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,hitting/bounded/exact/k-10,4.235450614942238e-05,5.414985935203731e-07,4.1802009945968166e-05,4.283300586394034e-05,4.202049603918567e-05,4.258349508745596e-05,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,hitting/bounded/exact/k-100,0.00033752100716810673,3.0205046641640365e-06,0.00033381200046278536,0.00034016649442492053,0.000335375007125549,0.00033981249725911766,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,hitting/bounded/greater-than/k-10,4.408400127431378e-05,6.659902282990515e-07,4.342673855717294e-05,4.469774285098538e-05,4.368749796412885e-05,4.441599594429135e-05,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,hitting/bounded/greater-than/k-100,0.0003371045022504404,2.3749962565489113e-06,0.0003331142543174792,0.0003393124970898498,0.00033566600177437067,0.0003387500037206337,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,occupation-matrix,0.0008701660044607706,4.020505002699792e-06,0.0008660832536406815,0.000873884760949295,0.0008676249999552965,0.0008726249943720177,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,power/10,0.000311479001538828,1.2914970284327865e-06,0.0003103127528447658,0.0003134795006189961,0.00031037500593811274,0.0003124595359622617,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,power/100,0.0003145205046166666,1.1669981176964939e-06,0.0003134267535642721,0.00031587549892719835,0.0003136254963465035,0.00031516700983047485,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,power/2,0.00030935399990994483,1.9379949662834406e-06,0.0003074160049436614,0.00031116650279727764,0.0003084579948335886,0.0003110209945589304,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,return/bounded/k-10,4.3562504288274795e-05,9.165014489553869e-07,4.251025166013278e-05,4.432349669514224e-05,4.270799399819225e-05,4.4103995605837554e-05,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,return/bounded/k-100,0.00034183299430878833,1.6665071598254144e-06,0.00033101049848482944,0.0003429065036471002,0.00033770799927879125,0.0003426664916332811,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,stationary,0.00010062499495688826,2.1039959392510355e-06,9.879200661089271e-05,0.00010394774290034547,9.943750774255022e-05,0.00010270850179949775,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,structure/classes-cold,3.243749961256981e-05,1.1665033525787294e-06,3.117700180155225e-05,3.3531494409544393e-05,3.183400258421898e-05,3.316700895084068e-05,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,structure/classes-lifecycle,0.0004503539967117831,8.854505722410977e-06,0.00043865599946002476,0.00045820825107512064,0.0004422709971549921,0.00045495800441130996,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,structure/classes-warm/access,2.1703545062337072e-07,6.917005521245573e-10,2.1675940006389284e-07,2.185604000260355e-07,2.1680205027223566e-07,2.1814170031575487e-07,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,structure/classes-warm/consumed,9.870687492366414e-07,2.5395995180588463e-09,9.84012500339304e-07,9.89342699176632e-07,9.85166128957644e-07,9.883665989036672e-07,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,structure/irreducible-cold,2.9312490369193256e-05,5.204856279306114e-07,2.8844257030868903e-05,3.000024298671633e-05,2.895800571423024e-05,2.9688002541661263e-05,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,structure/irreducible-warm,2.2527500113938005e-07,7.375499990303179e-10,2.2452087541751098e-07,2.259656503156293e-07,2.2473329881904648e-07,2.2573754977202044e-07,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,visits/bounded-expectation/k-10,1.9708502804860473e-05,2.9200600693002343e-07,1.9427247025305405e-05,2.006224895012565e-05,1.9499995687510818e-05,1.9958504708483815e-05,30 +pydtmc,absorbing-n0010-s02718,absorbing,10,2718,visits/bounded-expectation/k-100,7.770900265313685e-05,2.9199873097240925e-07,7.746849951217882e-05,7.817674122634344e-05,7.756250124657527e-05,7.797949365340173e-05,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,absorption-time,0.00017602099978830665,4.938003257848322e-06,0.00017059375386452302,0.0001794477466319222,0.00017150000348920003,0.00017860450316220522,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,absorption/probabilities,0.00017587550246389583,3.3340038498863578e-06,0.0001733230055833701,0.0001815725045162253,0.00017387499974574894,0.00018074999388772994,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,construction/public-consumed,0.00037966649688314646,7.874994480516762e-06,0.00037538549440796487,0.0003905417433998082,0.0003761255065910518,0.0003875414913636632,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,evolution/k-10,5.129149940330535e-05,4.374960553832352e-07,5.088524630991742e-05,5.21042529726401e-05,5.099999543745071e-05,5.154199607204646e-05,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,evolution/k-100,0.0002583540044724941,8.95997800398618e-07,0.00025768774503376335,0.00025925000954885036,0.0002578329876996577,0.0002591045049484819,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,evolution/one-step,2.9645496397279203e-05,4.784960765391588e-07,2.9260500014061108e-05,3.111450496362522e-05,2.9374998121056706e-05,3.0229501135181636e-05,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,finite-time/n-step/k-10,4.9479502195026726e-05,6.040063453838229e-07,4.9166250391863286e-05,5.06979959027376e-05,4.924999666400254e-05,5.0125003326684237e-05,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,finite-time/n-step/k-100,0.00025752049987204373,1.6455014701932669e-06,0.00025609425574657507,0.00026169800185016356,0.00025629149604355916,0.0002600840016384609,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,finite-time/observation/k-10,5.0040995120070875e-05,6.869886419735849e-07,4.946849003317766e-05,5.0843747885664925e-05,4.960400110576302e-05,5.0583999836817384e-05,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,finite-time/observation/k-100,0.00025697950331959873,8.335046004503965e-07,0.00025588550488464534,0.00025765650570974685,0.00025643800472607836,0.00025758300034794956,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,finite-time/step,8.749993867240846e-07,4.1996827349066734e-08,8.33999365568161e-07,9.170034900307655e-07,8.33999365568161e-07,9.169962140731514e-07,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,fundamental-matrix,0.00016439550381619483,2.1665109670720994e-06,0.00016288474580505863,0.000170021245139651,0.0001635209991945885,0.00016858299932209775,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,hitting-probability/cold-all-states,4.4271000660955906e-05,1.2710006558336318e-06,4.297949999454431e-05,4.539599467534572e-05,4.322899621911347e-05,4.506249388214201e-05,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,hitting-time/cold-all-states,9.137499728240073e-05,2.0000006770715117e-06,8.97919999260921e-05,9.392725041834638e-05,8.98750004125759e-05,9.249950380763039e-05,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,hitting/bounded/at-most/k-10,4.433349386090413e-05,6.879927241243422e-07,4.361425089882687e-05,4.485425597522408e-05,4.381296876090346e-05,4.4708503992296755e-05,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,hitting/bounded/at-most/k-100,0.00033785400592023507,1.1044976417906582e-06,0.0003366662567714229,0.00033858300230349414,0.00033716700272634625,0.0003383959992788732,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,hitting/bounded/exact/k-10,4.262499714968726e-05,3.540044417604804e-07,4.2302246583858505e-05,4.310425720177591e-05,4.239549889462069e-05,4.295801045373082e-05,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,hitting/bounded/exact/k-100,0.0003340210023452528,3.832996299024671e-06,0.00033037525645340793,0.00033958349740714766,0.00033135400008177385,0.00033647949749138206,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,hitting/bounded/greater-than/k-10,4.433349386090413e-05,8.129936759360135e-07,4.358275327831507e-05,4.520850416156463e-05,4.3832988012582064e-05,4.462499782675877e-05,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,hitting/bounded/greater-than/k-100,0.0003396454994799569,1.5834957594051957e-06,0.00033816600262071006,0.00034111424611182883,0.00033868749596877024,0.00034068750392179936,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,occupation-matrix,0.000873791505000554,6.854505045339465e-06,0.0008681877479830291,0.0008810309955151752,0.0008696254953974858,0.0008795414978521876,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,power/10,0.0003133959980914369,1.1669908417388797e-06,0.00031242749173543416,0.0003148027499264572,0.00031251998425432245,0.0003143124995403923,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,power/100,0.00031191649759421125,1.6039994079619646e-06,0.00031033324557938613,0.0003139475011266768,0.00031056200532475486,0.00031258400122169405,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,power/2,0.0003103124981862493,1.3129974831826985e-06,0.0003093229970545508,0.00031176050106296316,0.00030960449657868594,0.0003112909907940775,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,return/bounded/k-10,4.325000918470323e-05,4.5850174501538277e-07,4.287499177735299e-05,4.4645745219895616e-05,4.287500632926822e-05,4.375050775706768e-05,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,return/bounded/k-100,0.00033420900581404567,2.334010787308216e-06,0.00033274973975494504,0.0003427812443987932,0.00033297899790341035,0.0003397504988242872,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,stationary,0.00010158350050915033,3.4165059332735837e-06,9.718725050333887e-05,0.00010412475967314094,9.833193525992101e-05,0.00010343749454477802,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,structure/classes-cold,2.9625000024680048e-05,6.044938345439732e-07,2.9260252631502226e-05,3.044849290745333e-05,2.9333503334783018e-05,3.0000010156072676e-05,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,structure/classes-lifecycle,0.00043816649849759415,2.666500222403556e-06,0.0004357287434686441,0.00044088525100960396,0.00043695799831766635,0.0004392080008983612,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,structure/classes-warm/access,2.172812499338761e-07,1.1457996151875636e-09,2.1638125035678967e-07,2.3992709975573234e-07,2.171165993786417e-07,2.280062501085922e-07,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,structure/classes-warm/consumed,9.865895997791086e-07,3.6728997656609406e-09,9.839416747126963e-07,9.905114497087197e-07,9.843229505349882e-07,9.893417001876513e-07,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,structure/irreducible-cold,2.937499084509909e-05,9.58512828219682e-07,2.803124880301766e-05,3.019775977008976e-05,2.845849667210132e-05,2.9999995604157448e-05,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,structure/irreducible-warm,2.229396006441675e-07,3.7079953472130765e-10,2.227385492005851e-07,2.244999741378706e-07,2.2277294992818498e-07,2.2368960053427145e-07,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,visits/bounded-expectation/k-10,1.983399852178991e-05,3.1350646167993546e-07,1.955149491550401e-05,2.0208244677633047e-05,1.9625003915280104e-05,1.9958490156568587e-05,30 +pydtmc,absorbing-n0010-s31415,absorbing,10,31415,visits/bounded-expectation/k-100,7.824999920558184e-05,4.169996827840805e-07,7.79169931774959e-05,7.873975118855014e-05,7.797849902999588e-05,7.858400931581855e-05,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,absorption-time,0.00048291699204128236,4.64549520984292e-06,0.0004784692500834353,0.00048722924111643806,0.00047968750004656613,0.00048452099872520193,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,absorption/probabilities,0.0004960000005667098,4.1454986785538495e-06,0.0004923957567370962,0.0005002495054213796,0.0004938329948345199,0.0004993960028514266,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,construction/public-consumed,0.0010072084987768903,3.0000010156072676e-06,0.0010047605028375983,0.0010103127533511724,0.001006167003652081,0.0010087710033985786,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,evolution/k-10,6.450000364566222e-05,6.664995453320444e-07,6.398999903467484e-05,6.523950287373737e-05,6.410400237655267e-05,6.483400647994131e-05,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,evolution/k-100,0.000281229498796165,1.5619953046552837e-06,0.00027981274979538284,0.00028325025050435215,0.00028043799102306366,0.00028268749883864075,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,evolution/one-step,4.2478997784201056e-05,6.669943104498088e-07,4.2031249904539436e-05,4.416699812281877e-05,4.2270999983884394e-05,4.345898923929781e-05,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,finite-time/n-step/k-10,6.308299634838477e-05,6.664995453320444e-07,6.256275810301304e-05,6.447949635912664e-05,6.268750439630821e-05,6.383299478329718e-05,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,finite-time/n-step/k-100,0.0002763754964689724,3.0834999051876366e-06,0.00027327099815011024,0.00027821874755318277,0.00027425049484008923,0.0002773750020423904,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,finite-time/observation/k-10,6.337450759019703e-05,9.78507159743458e-07,6.25102584308479e-05,6.469776053563692e-05,6.26874971203506e-05,6.416699034161866e-05,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,finite-time/observation/k-100,0.0002775830071186647,1.3959943316876888e-06,0.00027656275415210985,0.0002794167521642521,0.00027675049932440743,0.00027862549904966727,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,finite-time/step,1.291002263315022e-06,4.200410330668092e-08,1.2499949662014842e-06,1.33301000460051e-06,1.2499949662014842e-06,1.3329990906640887e-06,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,fundamental-matrix,0.0004977710050297901,4.270994395483285e-06,0.0004938230013067368,0.0005020630014769267,0.000495375003083609,0.0005015210044803098,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,hitting-probability/cold-all-states,6.956250581424683e-05,1.0000003385357559e-06,6.888525240356103e-05,7.147874566726387e-05,6.912500248290598e-05,7.060400093905628e-05,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,hitting-time/cold-all-states,0.00014233349793357775,2.3330067051574588e-06,0.00014067699521547183,0.0001455212513974402,0.0001412290002917871,0.00014479200035566464,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,hitting/bounded/at-most/k-10,6.045800546417013e-05,5.624970071949065e-07,6.002074223943055e-05,6.130200563347898e-05,6.0104503063485026e-05,6.10839924775064e-05,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,hitting/bounded/at-most/k-100,0.0005381874943850562,1.810349931474775e-05,0.0005200837549637072,0.0005547910041059367,0.000524874500115402,0.0005497079982887954,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,hitting/bounded/exact/k-10,5.887499719392508e-05,9.57996235229075e-07,5.8249996072845533e-05,6.32505070825573e-05,5.839600635226816e-05,6.07041787588968e-05,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,hitting/bounded/exact/k-100,0.0005127080003148876,8.81250889506191e-06,0.000507364504301222,0.0005290727531246375,0.0005092705032438971,0.000523916503880173,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,hitting/bounded/greater-than/k-10,6.489550287369639e-05,2.270506229251623e-06,6.269824370974675e-05,6.706225394736975e-05,6.35419874015497e-05,6.645850226050243e-05,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,hitting/bounded/greater-than/k-100,0.000510728990775533,2.9165021260268986e-06,0.000508614244608907,0.0005149687458469998,0.0005093125000712462,0.0005135031280588009,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,occupation-matrix,0.004814478998014238,1.1083000572398305e-05,0.004808843495993642,0.004893249501037644,0.004810020502191037,0.004858583495661151,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,power/10,0.0005375415057642385,3.0205046641640365e-06,0.000535239749297034,0.0005408647448348347,0.00053570800810121,0.0005400004956754856,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,power/100,0.0005480210020323284,5.083500582259148e-06,0.0005406874988693744,0.0005521662387764081,0.0005447080038720742,0.0005502709973370656,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,power/2,0.000540603999979794,5.5829950724728405e-06,0.0005374165011744481,0.0005511359995580278,0.0005391875019995496,0.0005480624968186021,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,return/bounded/k-10,6.029150972608477e-05,9.164941729977727e-07,5.9458252508193254e-05,6.120800389908254e-05,5.962450086371973e-05,6.116700387792662e-05,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,return/bounded/k-100,0.0004999379962100647,1.0958494385704398e-05,0.0004915832469123416,0.0005681254988303408,0.0004952710078214295,0.0005332909931894392,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,stationary,0.00030839549435768276,2.479500835761428e-06,0.0003070209968427662,0.0003116669977316633,0.0003072709951084107,0.0003108749951934442,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,structure/classes-cold,0.00011889550660271198,3.478999133221805e-06,0.00011683375487336889,0.00012276000416022725,0.00011824999091913924,0.0001222300314111635,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,structure/classes-lifecycle,0.001178166494355537,1.0583498806226999e-05,0.0011694582499330863,0.0011893022456206381,0.0011747084936359897,0.0011843954998767003,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,structure/classes-warm/access,2.2024999998393467e-07,2.760400093393391e-09,2.1950622576696332e-07,2.365728756558383e-07,2.1980414967401886e-07,2.2813329997006805e-07,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,structure/classes-warm/consumed,1.7835541497333907e-06,6.5854001150001255e-09,1.7795895997551268e-06,1.87863129976904e-06,1.7821312503656374e-06,1.863864599727094e-06,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,structure/irreducible-cold,0.00012266700650798157,1.271007931791246e-06,0.00012159349716966972,0.00012554200657177716,0.0001219374971697107,0.00012497900024754927,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,structure/irreducible-warm,2.2605205012951045e-07,6.271497113630257e-10,2.2534477539011276e-07,2.2657917470496615e-07,2.2559165008715355e-07,2.2641245013801382e-07,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,visits/bounded-expectation/k-10,3.191699943272397e-05,5.830006557516754e-07,3.1302501156460494e-05,3.242675302317366e-05,3.14585049636662e-05,3.227050183340907e-05,30 +pydtmc,absorbing-n0025-s01729,absorbing,25,1729,visits/bounded-expectation/k-100,9.66045045061037e-05,2.125510945916176e-06,9.467674681218341e-05,9.884374958346598e-05,9.554199641570449e-05,9.737499931361526e-05,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,absorption-time,0.000493708997964859,4.04199818149209e-06,0.0004897297476418316,0.0004981245037924964,0.0004910415009362623,0.0004971879970980808,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,absorption/probabilities,0.000500604000990279,4.875000740867108e-06,0.000497082743095234,0.0005068230020697229,0.0004984374972991645,0.0005054790017311461,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,construction/public-consumed,0.0010094580065924674,4.9579975893720984e-06,0.001004260248009814,0.0010134900112461764,0.0010065209935419261,0.0010124789987457916,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,evolution/k-10,6.487549399025738e-05,4.789981176145375e-07,6.46662520011887e-05,6.596874663955532e-05,6.468799256253988e-05,6.541599577758461e-05,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,evolution/k-100,0.0002818744978867471,2.1874948288314044e-06,0.00027913524900213815,0.0002835832565324381,0.00028035400464432314,0.0002827499993145466,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,evolution/one-step,4.25000034738332e-05,7.294947863556445e-07,4.214575164951384e-05,4.403075581649318e-05,4.225000157020986e-05,4.37500057159923e-05,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,finite-time/n-step/k-10,6.295849743764848e-05,5.214969860389829e-07,6.245824988582171e-05,6.384325024555437e-05,6.275000469031512e-05,6.322899571387097e-05,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,finite-time/n-step/k-100,0.0002786250042845495,1.5619953046552837e-06,0.00027734399918699637,0.00028029174427501857,0.0002778534948447486,0.00027985399356111884,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,finite-time/observation/k-10,6.366649904521182e-05,7.705020834691823e-07,6.312500045169145e-05,6.479150397353806e-05,6.331250187940896e-05,6.45005517071695e-05,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,finite-time/observation/k-100,0.00028241700056241825,2.2079984773881733e-06,0.0002803432507789694,0.0002846454954124056,0.0002815415064105764,0.0002841254972736351,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,finite-time/step,1.2920063454657793e-06,6.250775186344981e-08,1.2499949662014842e-06,1.3647586456499994e-06,1.2500095181167126e-06,1.3329990906640887e-06,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,fundamental-matrix,0.0004843130009248853,9.291499736718833e-06,0.00047776000428711995,0.0004970727459294721,0.0004797079964191653,0.0004947289926349185,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,hitting-probability/cold-all-states,6.983349157962948e-05,1.1664960766211152e-06,6.885449693072587e-05,7.203149289125577e-05,6.922899774508551e-05,7.112498860806227e-05,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,hitting-time/cold-all-states,0.0001448124967282638,2.1045125322416425e-06,0.00014286449368228205,0.00014691700926050544,0.00014324999938253313,0.00014674999692942947,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,hitting/bounded/at-most/k-10,6.197950278874487e-05,1.7089987522922456e-06,6.057299469830468e-05,6.611449862248264e-05,6.09995040576905e-05,6.487500650109723e-05,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,hitting/bounded/at-most/k-100,0.0005101249989820644,7.0210007834248245e-06,0.0005055619985796511,0.0005230832503002603,0.0005058750030002557,0.0005158335043233819,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,hitting/bounded/exact/k-10,6.372950156219304e-05,1.7085039871744812e-06,6.0104004660388455e-05,6.476000271504745e-05,6.154150469228625e-05,6.437500996980816e-05,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,hitting/bounded/exact/k-100,0.0005876665018149652,2.4124492483679205e-05,0.000511822996486444,0.000600978746660985,0.0005216665085754357,0.0005986454998492263,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,hitting/bounded/greater-than/k-10,6.204099918249995e-05,6.469999789260328e-07,6.135424700914882e-05,6.265649426495656e-05,6.162501085782424e-05,6.245799886528403e-05,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,hitting/bounded/greater-than/k-100,0.0005167910057934932,6.561509508173913e-06,0.0005135102474014275,0.0005578754935413599,0.0005141250003362074,0.0005471670010592788,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,occupation-matrix,0.004823291499633342,2.8520495106931776e-05,0.004795739503606455,0.0048517807481403,0.004803625008207746,0.004844832998060156,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,power/10,0.0005409794976003468,1.978994987439364e-06,0.0005391460035752971,0.0005437605032057036,0.0005397915010689758,0.0005417079955805093,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,power/100,0.0005452499972307123,4.895504389423877e-06,0.0005409685036283918,0.0005521557577594649,0.000541208493814338,0.000549651235451165,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,power/2,0.0005490624971571378,9.686991688795388e-06,0.0005413437502284069,0.0005767807524534874,0.0005441875036922283,0.0005632709944620728,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,return/bounded/k-10,6.020900036673993e-05,6.675036274828017e-07,5.9801499446621165e-05,6.177049726829864e-05,5.989599594613537e-05,6.12090079812333e-05,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,return/bounded/k-100,0.0005085835073259659,9.687486453913152e-06,0.0004904792513116263,0.0005144274946360383,0.0004973960021743551,0.0005100415000924841,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,stationary,0.0003189374983776361,5.770503776147962e-06,0.00031157299963524565,0.0003227079978387337,0.00031406249763676897,0.0003222500017727725,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,structure/classes-cold,0.00012414599768817425,1.6250050975941122e-06,0.00012184350271127187,0.0001256142531929072,0.00012229198910063133,0.00012483300815802068,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,structure/classes-lifecycle,0.0011682085023494437,9.167008101940155e-06,0.001159864248620579,0.001177759997517569,0.0011620209988905117,0.001173438002297189,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,structure/classes-warm/access,2.1812710037920625e-07,8.041497494559789e-10,2.173885495722061e-07,2.1896972539252602e-07,2.1746040074503982e-07,2.1853335056221115e-07,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,structure/classes-warm/consumed,1.7778520501451568e-06,4.958350473316356e-09,1.7724937497405334e-06,1.7816666993894613e-06,1.7736853995302226e-06,1.781270800711354e-06,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,structure/irreducible-cold,0.00012383400462567806,1.7079946701414883e-06,0.00011910425018868409,0.00012440574209904298,0.00012191649875603616,0.00012422900181263685,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,structure/irreducible-warm,2.2512085051857867e-07,3.2494936021976436e-10,2.249364253657404e-07,2.25495824997779e-07,2.2497909958474338e-07,2.2544579987879843e-07,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,visits/bounded-expectation/k-10,3.1833995308261365e-05,1.4599936548620462e-07,3.171849675709382e-05,3.198974809492938e-05,3.1770498026162386e-05,3.195799945387989e-05,30 +pydtmc,absorbing-n0025-s02718,absorbing,25,2718,visits/bounded-expectation/k-100,9.458300337428227e-05,4.579997039400041e-07,9.424999370821752e-05,9.529150338494219e-05,9.44580024224706e-05,9.512500400887802e-05,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,absorption-time,0.0004903544977423735,2.896005753427744e-06,0.00048772975787869655,0.0004934687422064599,0.0004887499962933362,0.0004924790046061389,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,absorption/probabilities,0.0005089585029054433,4.771005478687584e-06,0.0005049475039413664,0.0005147922493051738,0.000506042008055374,0.0005132331703862291,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,construction/public-consumed,0.001008353996439837,6.291498721111566e-06,0.0010016980013460852,0.0010144687475985847,0.0010050835044239648,0.0010128633764907135,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,evolution/k-10,6.472899985965341e-05,5.00003807246685e-07,6.438550917664543e-05,6.597875108127482e-05,6.447900523198768e-05,6.53750030323863e-05,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,evolution/k-100,0.0002801249938784167,1.666492607910186e-06,0.00027804150886368006,0.0002815829939208925,0.00027935399702982977,0.00028137500339653343,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,evolution/one-step,4.272950172889978e-05,6.669943104498088e-07,4.2301744542783126e-05,4.3906249629799277e-05,4.237499524606392e-05,4.320800508139655e-05,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,finite-time/n-step/k-10,6.395849777618423e-05,1.353990228381008e-06,6.259425572352484e-05,6.518725422210991e-05,6.27919944236055e-05,6.481200398411602e-05,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,finite-time/n-step/k-100,0.0002767710029729642,1.708496711216867e-06,0.000275177248113323,0.00027890649653272703,0.000275792001048103,0.0002785419928841293,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,finite-time/observation/k-10,6.437500269385055e-05,1.72900763573125e-06,6.297900108620524e-05,6.666675471933559e-05,6.327050505205989e-05,6.652100273640826e-05,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,finite-time/observation/k-100,0.00027822950505651534,2.6040070224553347e-06,0.0002764269956969656,0.0002811557496897876,0.0002769164930214174,0.0002803750030579977,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,finite-time/step,1.2909949873574078e-06,8.299684850499034e-08,1.2080017768312246e-06,1.3749959180131555e-06,1.229003828484565e-06,1.2920063454657793e-06,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,fundamental-matrix,0.0004936460027238354,2.5000044843181968e-06,0.0004913122429570649,0.0004961142512911465,0.000492103476972261,0.0004955829936079681,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,hitting-probability/cold-all-states,7.12710025254637e-05,2.0625084289349616e-06,6.962499173823744e-05,7.434374856529757e-05,6.987550295889378e-05,7.341650052694604e-05,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,hitting-time/cold-all-states,0.0001457920006942004,4.854999133385718e-06,0.00014176049080560915,0.00015167675883276388,0.00014202099555404857,0.0001509790017735213,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,hitting/bounded/at-most/k-10,6.477050192188472e-05,1.791995600797236e-06,6.084399501560256e-05,6.594800652237609e-05,6.279149238253012e-05,6.566649972228333e-05,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,hitting/bounded/at-most/k-100,0.0005138750057085417,2.7290006983093917e-06,0.00051254199934192,0.0005371559964260086,0.0005127709955559112,0.0005257704979158007,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,hitting/bounded/exact/k-10,6.039549771230668e-05,7.914932211861014e-07,5.935349690844305e-05,6.107274384703487e-05,5.964550655335188e-05,6.0792001022491604e-05,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,hitting/bounded/exact/k-100,0.000515583495143801,1.4083001588005573e-05,0.0005025210084568243,0.0005543752486119047,0.0005071249979664572,0.0005369375066948123,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,hitting/bounded/greater-than/k-10,6.49585053906776e-05,1.9369908841326833e-06,6.229199425433762e-05,6.655199831584468e-05,6.320849934127182e-05,6.631299766013399e-05,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,hitting/bounded/greater-than/k-100,0.0005085630109533668,4.1875100578181446e-06,0.0005057187445345335,0.0005136462423251942,0.000507353476677963,0.0005127090043970384,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,occupation-matrix,0.00483504149451619,2.441700780764222e-05,0.004803854004421737,0.00485768774888129,0.004812166007468477,0.004850290992180817,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,power/10,0.0005349374987417832,1.3540047802962363e-06,0.000533698002982419,0.0005363122509152163,0.0005342919976101257,0.0005357710033422336,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,power/100,0.0005463540001073852,5.437505024019629e-06,0.0005396457563620061,0.0005502290005097166,0.000542958005098626,0.0005494369979714975,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,power/2,0.0005358959970180877,5.979498382657766e-06,0.0005310102460498456,0.0005435622479126323,0.0005325419988366775,0.0005397704953793436,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,return/bounded/k-10,6.181250500958413e-05,8.955030352808535e-07,6.097975710872561e-05,6.278124783420935e-05,6.1249993450474e-05,6.243700045160949e-05,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,return/bounded/k-100,0.0005110205092933029,3.5625052987597883e-06,0.0005074159998912364,0.0005135837564012036,0.0005076460001873784,0.0005128335033077747,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,stationary,0.00031391649827128276,1.8749997252598405e-06,0.0003113330021733418,0.00031515649607172236,0.00031222899997374043,0.0003149994954583235,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,structure/classes-cold,0.00012052100646542385,5.210022209212184e-07,0.00012013599189231172,0.00012207324834889732,0.00012029199569951743,0.0001210215208629961,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,structure/classes-lifecycle,0.001179333499749191,3.729495801962912e-06,0.001176125238998793,0.0011867294997500721,0.0011768749973271042,0.0011824370012618601,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,structure/classes-warm/access,2.1702500016544946e-07,8.167000487446785e-10,2.1611354968626986e-07,2.1775527529825922e-07,2.1632499920087868e-07,2.1755410052719525e-07,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,structure/classes-warm/consumed,1.7798687498725487e-06,8.131199865602096e-09,1.7727750255289722e-06,1.7977959003474098e-06,1.7738103997544387e-06,1.795320800738409e-06,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,structure/irreducible-cold,0.00012081250315532088,1.9584986148402095e-06,0.00011842700041597709,0.00012268725549802184,0.00012027050252072513,0.00012235449685249478,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,structure/irreducible-warm,2.2473335047834553e-07,1.3792006939184008e-09,2.2381455019058197e-07,2.27654175250791e-07,2.2414584964280947e-07,2.2658754969597793e-07,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,visits/bounded-expectation/k-10,3.158349863952026e-05,2.709930413402617e-07,3.1396004487760365e-05,3.1906496587907895e-05,3.1520496122539043e-05,3.1771000067237765e-05,30 +pydtmc,absorbing-n0025-s31415,absorbing,25,31415,visits/bounded-expectation/k-100,9.610399865778163e-05,8.330025593750179e-07,9.485425471211784e-05,9.656224938225932e-05,9.522950131213292e-05,9.643750672694296e-05,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,absorption-time,0.0014102295026532374,2.9437491321004927e-05,0.0013853332566213794,0.001441000491468003,0.001395748442337208,0.0014347499964060262,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,absorption/probabilities,0.0013978334973216988,1.6666497685946524e-05,0.0013855830002285074,0.0014241664975997992,0.0013885415028198622,0.001422895998985041,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,construction/public-consumed,0.003317458991659805,1.4271492545958608e-05,0.0033026352502929512,0.003323999757412821,0.003305333506432362,0.003321583499200642,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,evolution/k-10,8.866700227372348e-05,7.50500475987792e-07,8.798925409791991e-05,8.948999675340019e-05,8.820799830573378e-05,8.912499470170587e-05,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,evolution/k-100,0.0003219165009795688,2.9579969123005867e-06,0.00031841725285630673,0.0003242602506361436,0.0003196875040885061,0.0003230204965802841,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,evolution/one-step,6.358350219670683e-05,8.329952834174037e-07,6.279174704104662e-05,6.438498894567601e-05,6.304150156211108e-05,6.404099985957146e-05,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,finite-time/n-step/k-10,8.618750143796206e-05,8.540009730495512e-07,8.52604971441906e-05,8.684400381753221e-05,8.53750025271438e-05,8.656250429339707e-05,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,finite-time/n-step/k-100,0.0003150414995616302,2.8534996090456843e-06,0.0003131045050395187,0.0003204374952474609,0.0003135210063192062,0.0003178335027769208,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,finite-time/observation/k-10,8.585400064475834e-05,8.545030141249299e-07,8.497874659951776e-05,8.665576024213806e-05,8.525000885128975e-05,8.650000381749123e-05,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,finite-time/observation/k-100,0.00032031199953053147,1.1675001587718725e-06,0.0003193334960087668,0.00032155224471352994,0.0003195830067852512,0.0003207500049029477,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,finite-time/step,1.5830009942874312e-06,8.300412446260452e-08,1.4999968698248267e-06,1.6557532944716513e-06,1.541498932056129e-06,1.624997821636498e-06,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,fundamental-matrix,0.0013977084963698871,1.6708487237337977e-05,0.0013850625036866404,0.0014333540057123173,0.0013876875018468127,0.0014305619988590479,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,hitting-probability/cold-all-states,0.00017935399955604225,1.270498614758253e-06,0.00017817724801716395,0.00018098949658451602,0.00017843750538304448,0.0001800625104806386,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,hitting-time/cold-all-states,0.0003597704926505685,1.6874837456271052e-06,0.0003580830089049414,0.0003609687519201543,0.0003582085046218708,0.00036031249328516424,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,hitting/bounded/at-most/k-10,8.70829971972853e-05,6.460031727328897e-07,8.656275167595595e-05,8.781225187703967e-05,8.666650683153421e-05,8.760450145928189e-05,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,hitting/bounded/at-most/k-100,0.0007654789951629937,1.1354495654813945e-05,0.0007557192475360353,0.0007777814971632324,0.0007574585106340237,0.0007757084968034178,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,hitting/bounded/exact/k-10,8.543749572709203e-05,6.249902071431279e-07,8.50000069476664e-05,8.636475104140118e-05,8.506298963766312e-05,8.604250942880754e-05,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,hitting/bounded/exact/k-100,0.0007445630035363138,1.2542506738100201e-05,0.0007339895018958487,0.000875000001542503,0.0007372704931185581,0.0008219579976866953,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,hitting/bounded/greater-than/k-10,8.708349196240306e-05,3.749955794773996e-07,8.680174869368784e-05,8.767701001488604e-05,8.691649418324232e-05,8.735449955565855e-05,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,hitting/bounded/greater-than/k-100,0.0007546459964942187,7.02050601830706e-06,0.000748489754187176,0.0007617917472089175,0.0007512500014854595,0.0007611670007463545,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,occupation-matrix,0.0190581455026404,5.360400245990604e-05,0.018999624746356858,0.019094770756055368,0.01901727099902928,0.019076125005085487,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,power/10,0.0013492290017893538,2.2770502255298197e-05,0.001334624506853288,0.001376541011268273,0.001336146000539884,0.0013689159968635067,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,power/100,0.0013518125051632524,1.4354001905303448e-05,0.0013398855007835664,0.001380520494421944,0.0013418335001915693,0.001366520496958401,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,power/2,0.001340999995591119,1.585400605108589e-05,0.0013265519955893978,0.0013545100046030711,0.0013376249989960343,0.0013492500002030283,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,return/bounded/k-10,8.604149479651824e-05,9.789873729459941e-07,8.512475687894039e-05,8.713575152796693e-05,8.54164973134175e-05,8.672900730744004e-05,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,return/bounded/k-100,0.0007447709940606728,1.3770986697636545e-05,0.0007354892477451358,0.000806187505077105,0.000740479001251515,0.000760082999477163,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,stationary,0.001048624500981532,1.1396492482163012e-05,0.0010148020010092296,0.001057666497217724,0.001044208496750798,0.0010542651447394745,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,structure/classes-cold,0.00043983350769849494,2.1460073185153306e-06,0.0004355312485131435,0.0004412397465785034,0.0004376875003799796,0.0004409790053614415,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,structure/classes-lifecycle,0.0038401880010496825,2.039600076386705e-05,0.003821843747573439,0.0038639477570541203,0.0038253477365287835,0.0038596055779635207,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,structure/classes-warm/access,2.172916996642016e-07,1.0416508303023968e-09,2.1616880039800892e-07,2.181187752285041e-07,2.1633129945257678e-07,2.1775420027552173e-07,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,structure/classes-warm/consumed,3.046554150932934e-06,6.600001506740184e-09,3.0412708507356e-06,3.0590395501349124e-06,3.0437812500167636e-06,3.0526562506565826e-06,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,structure/irreducible-cold,0.0004272290025255643,4.312001692596823e-06,0.00042493699947954156,0.0004327809983806219,0.000425561457996082,0.0004319589934311807,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,structure/irreducible-warm,2.247395495942328e-07,8.228504157159407e-10,2.2400722446036526e-07,2.434906498820055e-07,2.2416669962694866e-07,2.346403640513006e-07,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,visits/bounded-expectation/k-10,5.222950130701065e-05,4.1649036575108767e-07,5.1937749958597124e-05,5.28227501490619e-05,5.202100146561861e-05,5.264599913061829e-05,30 +pydtmc,absorbing-n0050-s01729,absorbing,50,1729,visits/bounded-expectation/k-100,0.00012974999845027924,1.0209987522102892e-06,0.00012877100380137563,0.00013084375314065255,0.00012906250049127266,0.00013049999688519165,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,absorption-time,0.0013885834996472113,1.7499995010439306e-05,0.001378427248710068,0.0014273439956014045,0.0013799165026284754,0.0014265410136431456,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,absorption/probabilities,0.0014554785084328614,1.2438489648047835e-05,0.0014262602489907295,0.0014629482575401198,0.0014441039966186509,0.0014600010796129935,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,construction/public-consumed,0.0032913545073824935,9.6454969025217e-06,0.00327258275137865,0.0032993750028254,0.0032819680744069044,0.0032955209971987642,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,evolution/k-10,8.822899690130726e-05,1.1249867384321988e-06,8.739599797991104e-05,8.959374827099964e-05,8.762449251662475e-05,8.916649676393718e-05,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,evolution/k-100,0.00032060450030257925,2.874992787837982e-06,0.0003174582525389269,0.00032278075377689674,0.00031837499409448355,0.0003223959938623011,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,evolution/one-step,6.441699952119961e-05,8.540009730495512e-07,6.354200013447553e-05,6.508349906653166e-05,6.36254990240559e-05,6.493800174212083e-05,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,finite-time/n-step/k-10,8.57920094858855e-05,6.67001586407423e-07,8.5426501755137e-05,8.729223918635398e-05,8.55410035001114e-05,8.675206299812999e-05,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,finite-time/n-step/k-100,0.00032156250381376594,2.0205043256282806e-06,0.0003189689959981479,0.00032330175599781796,0.00031954199948813766,0.00032268750510411337,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,finite-time/observation/k-10,8.579200220992789e-05,9.584910003468394e-07,8.487475497531705e-05,8.670849638292566e-05,8.529200567863882e-05,8.6500498582609e-05,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,finite-time/observation/k-100,0.00031868750374997035,1.4579927665181458e-06,0.00031697900340077467,0.00031982274595065974,0.00031743749423185363,0.00031968799885362387,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,finite-time/step,1.624997821636498e-06,8.299684850499034e-08,1.5419973351527005e-06,1.6977392078842968e-06,1.5420082490891218e-06,1.6669946489855647e-06,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,fundamental-matrix,0.001417083498381544,1.4916506188455969e-05,0.0014050517493160442,0.001432291501259897,0.0014091249977354892,0.0014254794950829819,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,hitting-probability/cold-all-states,0.00017977049719775096,1.6459962353110313e-06,0.00017871900126920082,0.00018235374955111183,0.00017893749463837594,0.00018112499674316496,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,hitting-time/cold-all-states,0.0003613539956859313,1.9795115804299712e-06,0.00036042725332663395,0.0003635832545114681,0.0003606249956646934,0.0003630840074038133,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,hitting/bounded/at-most/k-10,8.745850209379569e-05,5.210022209212184e-07,8.702074774191715e-05,8.803149830782786e-05,8.725000225240365e-05,8.795850590104237e-05,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,hitting/bounded/at-most/k-100,0.000758313006372191,8.47899354994297e-06,0.0007525942564825527,0.0007691355094721075,0.0007536665070801973,0.0007663749929633923,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,hitting/bounded/exact/k-10,8.568749763071537e-05,5.00003807246685e-07,8.535450251656584e-05,8.636450002086349e-05,8.547899778932333e-05,8.612500096205622e-05,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,hitting/bounded/exact/k-100,0.0007590829991386272,1.3167504221200943e-05,0.0007390729915641714,0.0007692500075791031,0.00074608300201362,0.0007669999977224506,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,hitting/bounded/greater-than/k-10,8.743750368012115e-05,7.705093594267964e-07,8.666699068271555e-05,8.804175013210624e-05,8.69169962243177e-05,8.787450497038662e-05,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,hitting/bounded/greater-than/k-100,0.0007614584974362515,6.729002052452415e-06,0.000755959001253359,0.0007682187497266568,0.0007566249987576157,0.0007673954969504848,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,occupation-matrix,0.01898500049719587,0.0001003340003080666,0.01889176049735397,0.019221520247810986,0.018933062499854714,0.019142479002766777,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,power/10,0.0013493540027411655,8.68700590217486e-06,0.0013422912561509293,0.0013631252477352973,0.0013463540017255582,0.0013558539940277115,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,power/100,0.0013744164898525923,1.3603486877400428e-05,0.0013668335013790056,0.0013949267595307902,0.001370020501781255,0.0013849370006937534,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,power/2,0.0013466044983942993,2.466700243530795e-05,0.0013284272463351954,0.0014368125011969823,0.0013309370042406954,0.001426312497642357,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,return/bounded/k-10,8.689600508660078e-05,7.084963726811111e-07,8.6052248661872e-05,8.731224806979299e-05,8.639550651423633e-05,8.718750177649781e-05,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,return/bounded/k-100,0.0007598544980282895,9.6454969025217e-06,0.0007503855013055727,0.0007688642472203355,0.00075543750426732,0.0007670031101952191,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,stationary,0.0010379999948781915,9.583003702573478e-06,0.0010192392437602393,0.0010418337587907445,0.0010246040037600324,0.001040750001266133,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,structure/classes-cold,0.00043256249773548916,3.5625052987597883e-06,0.0004267917393008247,0.0004341979947639629,0.000430729502113536,0.0004336669953772798,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,structure/classes-lifecycle,0.003818228993623052,2.066700835712254e-05,0.0037936977423669305,0.00383583350412664,0.003803760755363328,0.0038316879945341498,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,structure/classes-warm/access,2.173813001718372e-07,7.769995136186412e-10,2.1626040070259477e-07,2.1780107526865321e-07,2.1634165022987873e-07,2.1770625025965272e-07,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,structure/classes-warm/consumed,3.0733895997400393e-06,9.710449376143178e-09,3.065276050256216e-06,3.0872750256094152e-06,3.0692208500113335e-06,3.0825271001958757e-06,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,structure/irreducible-cold,0.0004374584968900308,1.1438001820351928e-05,0.00042647925147321075,0.0004535102525551338,0.00043162500514881685,0.0004465215024538338,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,structure/irreducible-warm,2.2519584963447414e-07,9.062496246770031e-10,2.2444475071097258e-07,2.4960730006569066e-07,2.2463124914793298e-07,2.366832995903678e-07,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,visits/bounded-expectation/k-10,5.2313007472548634e-05,3.335007932037115e-07,5.208399670664221e-05,5.283299833536148e-05,5.212500400375575e-05,5.275000148685649e-05,30 +pydtmc,absorbing-n0050-s02718,absorbing,50,2718,visits/bounded-expectation/k-100,0.00012868749763583764,5.624970071949065e-07,0.00012822950884583406,0.00012947924915351905,0.00012833399523515254,0.0001291665030294098,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,absorption-time,0.00138422899908619,1.0479503544047475e-05,0.0013802812391077168,0.0013972500055388082,0.0013810834934702143,0.0013926460014772601,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,absorption/probabilities,0.001421374996425584,1.6936988686211407e-05,0.0014050420068087988,0.0014400620057131164,0.0014062499976716936,0.001435542006220203,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,construction/public-consumed,0.0032792914935271256,7.228998583741486e-06,0.0032731252431403846,0.0032874482458282728,0.003274983802839415,0.0032851249998202547,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,evolution/k-10,8.827100828057155e-05,9.369905455969274e-07,8.693749623489566e-05,8.915575381251983e-05,8.787499973550439e-05,8.912500197766349e-05,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,evolution/k-100,0.00032122900302056223,1.4580073184333742e-06,0.00032011449729907326,0.0003230932561564259,0.00032045850093709305,0.00032239600841421634,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,evolution/one-step,6.410400237655267e-05,8.335046004503965e-07,6.320799002423882e-05,6.486474740086123e-05,6.345692618197063e-05,6.474999827332795e-05,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,finite-time/n-step/k-10,8.608350617578253e-05,6.465124897658825e-07,8.54895006341394e-05,8.685448847245425e-05,8.568800694774836e-05,8.65420006448403e-05,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,finite-time/n-step/k-100,0.00031993750599212945,3.7710051401518285e-06,0.00031712499912828207,0.0003258127544540912,0.0003174794983351603,0.0003226455082767643,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,finite-time/observation/k-10,8.579150016885251e-05,8.335046004503965e-07,8.491649350617081e-05,8.644774425192736e-05,8.514549699611962e-05,8.620799781056121e-05,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,finite-time/observation/k-100,0.000319792001391761,1.0000003385357559e-06,0.0003186352478223853,0.00032056300187832676,0.000318812504701782,0.00032035399635788053,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,finite-time/step,1.6455014701932669e-06,6.250047590583563e-08,1.594253262737766e-06,1.7702441255096346e-06,1.624997821636498e-06,1.7080019460991025e-06,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,fundamental-matrix,0.001401562498358544,1.1791496945079416e-05,0.0013900000049034134,0.0014130622475931887,0.0013950415013823658,0.0014100835032877512,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,hitting-probability/cold-all-states,0.00017931250476976857,1.2500022421590984e-06,0.0001785935091902502,0.00018156299483962357,0.0001788334921002388,0.00018056250701192766,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,hitting-time/cold-all-states,0.000360041500243824,2.082997525576502e-06,0.00035872900116373785,0.0003635834982560482,0.00035902099625673145,0.0003627909973147325,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,hitting/bounded/at-most/k-10,8.850049925968051e-05,1.1665033525787294e-06,8.734425500733778e-05,8.977075049187988e-05,8.762450306676328e-05,8.931200136430562e-05,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,hitting/bounded/at-most/k-100,0.0007440629997290671,8.438000804744661e-06,0.0007351454987656325,0.0007503435008402448,0.0007377709989668801,0.0007472915021935478,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,hitting/bounded/exact/k-10,9.854150266619399e-05,6.81249366607517e-06,9.299976227339357e-05,0.00010536449917708524,9.36250071390532e-05,0.00010308299533789977,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,hitting/bounded/exact/k-100,0.0007702914954279549,1.2354495993349701e-05,0.0007594372509629466,0.0007823752457625233,0.000764291500672698,0.0007784789995639585,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,hitting/bounded/greater-than/k-10,8.772950968705118e-05,8.119895937852561e-07,8.714574505575001e-05,8.883350164978765e-05,8.73749959282577e-05,8.845850243233144e-05,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,hitting/bounded/greater-than/k-100,0.0007597295043524355,1.0959003702737391e-05,0.0007510834948334377,0.0007744062531855889,0.0007541249942732975,0.0007712914957664907,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,occupation-matrix,0.01897091649880167,8.787499973550439e-05,0.018842635243345285,0.019021030748263,0.01888310400681803,0.019011666998267174,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,power/10,0.0013607704968308099,1.5436999092344195e-05,0.0013456672531901859,0.001375874755467521,0.0013463750074151903,0.0013689374973182566,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,power/100,0.001374999999825377,1.1124997399747372e-05,0.0013661360026162583,0.0013939272466814145,0.001367541502986569,0.0013846045039827004,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,power/2,0.0013480625057127327,1.308351056650281e-05,0.0013349684959393926,0.001359718997264281,0.0013363954931264743,0.001356542001303751,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,return/bounded/k-10,8.672900003148243e-05,6.459958967752755e-07,8.626023918623105e-05,8.745898958295584e-05,8.633299876237288e-05,8.720799814909697e-05,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,return/bounded/k-100,0.0007576040079584345,8.437993528787047e-06,0.0007496567486668937,0.0007662505049665924,0.000752145511796698,0.0007635209985892288,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,stationary,0.001037312496919185,7.229507900774479e-06,0.0010167087530135177,0.001043375250446843,0.001033624997944571,0.0010405419961898588,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,structure/classes-cold,0.0004319165018387139,2.24999530473724e-06,0.0004300417494960129,0.00044459374475991353,0.00043027049832744524,0.00043970849219476804,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,structure/classes-lifecycle,0.003832833499473054,1.7708000086713582e-05,0.003815020751062548,0.003850207751384005,0.0038217499968595803,0.0038468959974125028,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,structure/classes-warm/access,2.176375004637521e-07,3.541499609127573e-10,2.1741145101259462e-07,2.181010248023085e-07,2.1745630074292422e-07,2.1795625070808455e-07,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,structure/classes-warm/consumed,3.0732395498489496e-06,1.699369968264367e-08,3.0569792248570594e-06,3.08974682520784e-06,3.060350000305334e-06,3.080660400155466e-06,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,structure/irreducible-cold,0.00043064600322395563,8.978997357189655e-06,0.0004182287520961836,0.00043875024130102247,0.000423395998950582,0.0004351459938334301,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,structure/irreducible-warm,2.2655209977529012e-07,1.995849743252626e-09,2.2497084937640465e-07,2.4264064959425013e-07,2.256250496429857e-07,2.3457531242456752e-07,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,visits/bounded-expectation/k-10,5.258299643173814e-05,5.00003807246685e-07,5.214575139689259e-05,5.3114759793970734e-05,5.2395502279978245e-05,5.30420002178289e-05,30 +pydtmc,absorbing-n0050-s31415,absorbing,50,31415,visits/bounded-expectation/k-100,0.0001299794967053458,9.169962140731514e-07,0.00012890624566352926,0.00013074975868221372,0.00012974948604096425,0.00013031250273343176,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,absorption-time,0.0046113124990370125,2.9708491638302803e-05,0.0045924275036668405,0.00468794749758672,0.0046030414960114285,0.0046618124906672165,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,absorption/probabilities,0.004761583506478928,2.4687513359822333e-05,0.0047446669996134005,0.00482193726929836,0.004747708007926121,0.00480952049838379,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,construction/public-consumed,0.01261272949341219,9.960400348063558e-05,0.01254557324864436,0.012809740015654825,0.01256718800868839,0.0127726874925429,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,evolution/k-10,0.00014072850171942264,2.7295027393847704e-06,0.00013887449313187972,0.00014743774227099493,0.000139520489028655,0.0001452290016459301,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,evolution/k-100,0.00044350000098347664,3.1870149541646242e-06,0.00044068800343666226,0.0004465727542992681,0.00044206250458955765,0.00044499999785330147,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,evolution/one-step,0.00010808350634761155,1.7920101527124643e-06,0.00010684350127121434,0.00011073949281126261,0.00010710449714679271,0.00010972849850077182,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,finite-time/n-step/k-10,0.00013791699893772602,1.2705131666734815e-06,0.00013730224600294605,0.00014066724543226883,0.0001374374987790361,0.00014027098950464278,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,finite-time/n-step/k-100,0.0004428329993970692,2.2504973458126187e-06,0.0004408120075822808,0.0004451457571121864,0.0004413540009409189,0.00044464806633186526,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,finite-time/observation/k-10,0.00013895798474550247,1.4784891391173005e-06,0.00013757275155512616,0.00014040600217413157,0.00013827050861436874,0.00013981250231154263,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,finite-time/observation/k-100,0.00044418701145332307,1.6239937394857407e-06,0.00044284426257945597,0.0004490317587624304,0.00044312396057648583,0.0004445829981705174,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,finite-time/step,3.0830124160274863e-06,1.6600824892520905e-07,2.9579969123005867e-06,3.3437463571317494e-06,2.979504643008113e-06,3.1665113056078553e-06,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,fundamental-matrix,0.004689666486228816,1.6542006051167846e-05,0.004668031251640059,0.004703155740571674,0.004674166484619491,0.004701375000877306,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,hitting-probability/cold-all-states,0.0008535414963262156,3.6454875953495502e-06,0.000851000237162225,0.0008590002471464686,0.0008516874950146303,0.0008564165036659688,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,hitting-time/cold-all-states,0.001704313006484881,5.603491445071995e-06,0.0017003962420858443,0.0017111664928961545,0.0017014789918903261,0.0017079579993151128,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,hitting/bounded/at-most/k-10,0.00017850000585895032,1.2500095181167126e-06,0.00017735400615492836,0.0001799375022528693,0.00017777099856175482,0.00017931299225892872,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,hitting/bounded/at-most/k-100,0.0017052710027201101,5.5209966376423836e-06,0.0017004167675622739,0.0017110619955928996,0.001701708504697308,0.0017094789945986122,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,hitting/bounded/exact/k-10,0.00017641698650550097,1.104010152630508e-06,0.00017583374574314803,0.00017803149239625782,0.00017600000137463212,0.0001773335097823292,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,hitting/bounded/exact/k-100,0.0016989580035442486,6.936999852769077e-06,0.0016941245048656128,0.0017089375032810494,0.0016951669967966154,0.0017074868330382742,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,hitting/bounded/greater-than/k-10,0.00017922949336934835,1.4170072972774506e-06,0.00017777075845515355,0.00018047950288746506,0.0001778959995135665,0.00018000000272877514,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,hitting/bounded/greater-than/k-100,0.0017042914987541735,3.5834964364767075e-06,0.0016984587491606362,0.001707135495962575,0.0017016665078699589,0.0017062709957826883,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,occupation-matrix,0.07682475000910927,0.0002648960071383044,0.07654259350238135,0.07705108351365197,0.07656147950910963,0.07695646475622198,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,power/10,0.004647666995879263,4.043799708597362e-05,0.004629875504178926,0.0047456245083594695,0.004631500007235445,0.004727353996713646,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,power/100,0.004746813006931916,3.7771009374409914e-05,0.004723999991256278,0.00482687474868726,0.004732146000606008,0.004761499498272315,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,power/2,0.004693312497693114,5.2770497859455645e-05,0.0046606354881078005,0.004774844252096955,0.0046740937334107,0.00474608299555257,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,return/bounded/k-10,0.0002331669966224581,1.8124512280337512e-05,0.00018148974777432159,0.0002484057331457734,0.0002046255103778094,0.00024114549160003662,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,return/bounded/k-100,0.001701875007711351,7.250491762533784e-06,0.0016952494988800026,0.0017095102593884803,0.0016969999996945262,0.001708416995825246,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,stationary,0.0038342079933499917,3.0187497031874955e-05,0.0038215210079215467,0.003870968495903071,0.0038237090047914535,0.0038609999901382253,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,structure/classes-cold,0.0016576039924984798,3.591700806282461e-05,0.001629250509722624,0.0017318022510153241,0.0016545414982829243,0.001713749996270053,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,structure/classes-lifecycle,0.014617624998209067,0.00028858298901468515,0.014433177253522445,0.015562374515866395,0.014498833494144492,0.015548625015071593,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,structure/classes-warm/access,2.176478985347785e-07,8.832983439788269e-10,2.1695412433473392e-07,2.191989740822464e-07,2.171000000089407e-07,2.189500504755415e-07,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,structure/classes-warm/consumed,5.652914650272578e-06,5.168699135538432e-09,5.64898022566922e-06,5.658439624676249e-06,5.649789600283838e-06,5.656847900536376e-06,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,structure/irreducible-cold,0.0017018545040627941,1.7999496776610613e-05,0.0016468437388539314,0.001718583756883163,0.0016828661453473616,0.0017159999842988327,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,structure/irreducible-warm,2.2670624894089997e-07,1.5750018064863961e-09,2.2597917559323833e-07,2.292822733579669e-07,2.2607499995501712e-07,2.2836670104879886e-07,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,visits/bounded-expectation/k-10,9.754100756254047e-05,1.501000951975584e-06,9.596924792276695e-05,9.881224832497537e-05,9.650000720284879e-05,9.789549221750349e-05,30 +pydtmc,absorbing-n0100-s01729,absorbing,100,1729,visits/bounded-expectation/k-100,0.00022802049352321774,1.1465162970125675e-06,0.00022689551406074315,0.0002291564960614778,0.00022756199177820235,0.00022881249606143683,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,absorption-time,0.004731542008812539,1.59579940373078e-05,0.0045348957501119,0.0047391252519446425,0.004631167001207359,0.004734542017104104,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,absorption/probabilities,0.004691937501775101,1.4583507436327636e-05,0.004677260491007473,0.004700770507042762,0.004682040991610847,0.004696062868242735,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,construction/public-consumed,0.01254481250362005,7.835401629563421e-05,0.01246411474130582,0.01261493800120661,0.012470458008465357,0.01260179199744016,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,evolution/k-10,0.00013937450421508402,1.5199912013486028e-06,0.00013791675155516714,0.00014123950677458197,0.0001382910122629255,0.00014025000564288348,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,evolution/k-100,0.0004433544963831082,4.62500611320138e-06,0.0004386772634461522,0.0004476040048757568,0.0004393130075186491,0.00044683349551633,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,evolution/one-step,0.00010918750194832683,1.8749997252598405e-06,0.00010737500269897282,0.00011110425111837685,0.00010783246689243242,0.00011027099390048534,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,finite-time/n-step/k-10,0.00013777050480712205,1.3540120562538505e-06,0.00013655174552695826,0.00013915650924900547,0.00013710347302549051,0.00013872952076781074,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,finite-time/n-step/k-100,0.0004444379883352667,3.4164986573159695e-06,0.0004415837611304596,0.0004488334816414863,0.0004419585020514205,0.000447750004241243,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,finite-time/observation/k-10,0.0001396455045323819,3.145003574900329e-06,0.00013666599988937378,0.00014339524204842746,0.00013704097364097834,0.00014114599616732448,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,finite-time/observation/k-100,0.0004431669949553907,5.625493940897286e-06,0.0004391252659843303,0.00045253099233377725,0.00044077100756112486,0.0004465209931368008,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,finite-time/step,3.437511622905731e-06,4.1698513086885214e-07,3.094261046499014e-06,5.593494279310107e-06,3.1460076570510864e-06,4.208995960652828e-06,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,fundamental-matrix,0.004653042007703334,4.622900451067835e-05,0.004614708013832569,0.004713729264040012,0.004616749502019957,0.004691062495112419,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,hitting-probability/cold-all-states,0.0008530000050086528,3.7290010368451476e-06,0.0008502812561346218,0.0008624789988971315,0.000850582990096882,0.0008569667992560426,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,hitting-time/cold-all-states,0.0017042079998645931,6.145506631582975e-06,0.0016987082562991418,0.0017106667582993396,0.0017006044945446774,0.0017082705162465572,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,hitting/bounded/at-most/k-10,0.00017745849618222564,1.1045049177482724e-06,0.00017681274766800925,0.00017977023526327685,0.00017697950534056872,0.00017904149717651308,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,hitting/bounded/at-most/k-100,0.0017051460163202137,5.374982720240951e-06,0.0016998852661345154,0.001710114738671109,0.0017012500029522926,0.0017078545060940087,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,hitting/bounded/exact/k-10,0.00017652100359555334,1.167005393654108e-06,0.00017534349899506196,0.00017742675845511258,0.0001756670098984614,0.00017716700676828623,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,hitting/bounded/exact/k-100,0.0016986039991024882,6.040994776412845e-06,0.001692427002126351,0.001703677247860469,0.0016953539889073,0.0017027089779730886,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,hitting/bounded/greater-than/k-10,0.00017747898527886719,1.1044758139178157e-06,0.00017654200200922787,0.0001794265044736676,0.00017689549713395536,0.00017858509527286513,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,hitting/bounded/greater-than/k-100,0.0017013125034281984,6.395988748408854e-06,0.0016968542477115989,0.0017124692676588893,0.001698292006039992,0.0017089374887291342,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,occupation-matrix,0.07719454199832398,0.0004549375007627532,0.07680966673797229,0.07767540575150633,0.07695879202219658,0.07751068750803825,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,power/10,0.004710270994110033,6.833350926171988e-05,0.004644739739887882,0.004777062757057138,0.004661520491936244,0.004747708502691239,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,power/100,0.004774916495080106,6.216698966454715e-05,0.004690791502071079,0.004805583237612154,0.004737041497719474,0.004796416498720646,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,power/2,0.004786645498825237,0.0001103544927900657,0.004706124738731887,0.004961927006661426,0.004735875001642853,0.0048915209918050095,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,return/bounded/k-10,0.0001764164917403832,1.249471097253263e-06,0.00017536474479129538,0.0001779792655725032,0.00017564550216775388,0.00017741700867190957,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,return/bounded/k-100,0.0016951664874795824,7.1459944592788815e-06,0.001690219243755564,0.0017026145142153837,0.0016916864828090182,0.0017020414816215634,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,stationary,0.0038468539860332385,9.208348637912422e-05,0.003759478757274337,0.0041879682466969825,0.003802832987275906,0.0039851459878263995,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,structure/classes-cold,0.0016749999776948243,1.4479475794360042e-05,0.0016653857455821708,0.0016976665065158159,0.0016660830151522532,0.0016963960079010576,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,structure/classes-lifecycle,0.014579561990103684,0.00014608350466005504,0.014531302251270972,0.01477832275122637,0.014539145995513536,0.014739125006599352,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,structure/classes-warm/access,2.181500007282011e-07,9.333511115983e-10,2.1730414882767944e-07,2.1925309847574682e-07,2.1754999906988814e-07,2.1871039934922009e-07,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,structure/classes-warm/consumed,5.63482084980933e-06,9.747900185175587e-09,5.628606201207731e-06,5.65161559934495e-06,5.630072900385131e-06,5.647520799539052e-06,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,structure/irreducible-cold,0.0016737294936319813,1.247850013896823e-05,0.0016590627710684203,0.0016856250003911555,0.0016695210069883615,0.0016825414932100102,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,structure/irreducible-warm,2.2803125029895455e-07,3.2707990612834843e-09,2.256666251923889e-07,2.5132187583949417e-07,2.263271002448164e-07,2.4029784981394184e-07,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,visits/bounded-expectation/k-10,9.752048936206847e-05,1.2085074558854103e-06,9.625025268178433e-05,9.867699554888532e-05,9.654200403019786e-05,9.787501767277718e-05,30 +pydtmc,absorbing-n0100-s02718,absorbing,100,2718,visits/bounded-expectation/k-100,0.00022902048658579588,1.811989932321012e-06,0.00022732325305696577,0.00023100000544218346,0.00022754099336452782,0.00023008348944131285,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,absorption-time,0.004659125494072214,2.581300213932991e-05,0.004631572744983714,0.00467554124770686,0.00463735350058414,0.004665771004511043,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,absorption/probabilities,0.0047492915036855265,3.068750083912164e-05,0.0047202292626025155,0.004778979513503145,0.00472943700151518,0.0047699375136289746,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,construction/public-consumed,0.012822104486986063,0.00023075001081451774,0.012411040996084921,0.013038437253271695,0.01265908349887468,0.013017874996876344,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,evolution/k-10,0.00013987500278744847,1.7500133253633976e-06,0.0001384269999107346,0.00014336399908643216,0.0001387289958074689,0.00014172900409903377,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,evolution/k-100,0.00044308300130069256,2.1460145944729447e-06,0.0004414375143824145,0.0004456979950191453,0.00044254149543121457,0.0004449626729183364,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,evolution/one-step,0.00010847901285160333,1.5214900486171246e-06,0.00010717650729930028,0.00011002126120729372,0.00010745800682343543,0.00010989549627993256,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,finite-time/n-step/k-10,0.0001379375025862828,1.270498614758253e-06,0.0001367399891023524,0.00013907248649047688,0.00013731249782722443,0.00013862500782124698,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,finite-time/n-step/k-100,0.00044643749424722046,1.1979500413872302e-05,0.0004370107490103692,0.0004919272323604673,0.00043885401100851595,0.00047131249448284507,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,finite-time/observation/k-10,0.00013972898887004703,1.791995600797236e-06,0.00013826000940753147,0.00014391700824489817,0.00013877099263481796,0.00014127101167105138,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,finite-time/observation/k-100,0.0004922290099784732,3.881299926433712e-05,0.00044691601942759007,0.0005167817580513656,0.0004537914937827736,0.0005082080024294555,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,finite-time/step,3.1039962777867913e-06,1.4599936548620462e-07,2.9582733986899257e-06,3.509732778184116e-06,3.0205119401216507e-06,3.31251067109406e-06,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,fundamental-matrix,0.0046609165001427755,2.5353991077281535e-05,0.004631770258129109,0.004682114238676149,0.004646604502340779,0.004673750008805655,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,hitting-probability/cold-all-states,0.000853145495057106,4.832982085645199e-06,0.0008490205073030666,0.0008599582579336129,0.0008499585092067719,0.0008567495096940547,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,hitting-time/cold-all-states,0.0017035625060088933,4.104003892280161e-06,0.0016996457416098565,0.0017086352527257986,0.001701062501524575,0.0017070419853553176,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,hitting/bounded/at-most/k-10,0.00017791699792724103,1.3124808901920915e-06,0.00017717701121000573,0.00017960449622478336,0.00017752050189301372,0.00017918749654199928,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,hitting/bounded/at-most/k-100,0.0017002495005726814,5.499503458850086e-06,0.0016969064890872687,0.0017070835165213794,0.0016990835138130933,0.0017029584851115942,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,hitting/bounded/exact/k-10,0.00020704150665551424,1.3229495380073786e-05,0.0001858647374319844,0.00021853175712749362,0.0002018750092247501,0.00021364550048019737,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,hitting/bounded/exact/k-100,0.0016986454866128042,8.688017260283232e-06,0.0016920110065257177,0.0017073962590075098,0.0016947085096035153,0.0017053749761544168,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,hitting/bounded/greater-than/k-10,0.00017866698908619583,1.167005393654108e-06,0.00017808350821724162,0.00018019827257376164,0.00017847899289336056,0.00017983349971473217,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,hitting/bounded/greater-than/k-100,0.0017060205136658624,4.541492671705782e-06,0.001703333735349588,0.0017106352606788278,0.001703896006802097,0.0017094580107368529,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,occupation-matrix,0.07700393699633423,0.0008493534987792373,0.07649844799016137,0.08093068774178391,0.07672939549956936,0.07918754775491833,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,power/10,0.004815292006242089,0.0001180835097329691,0.00470127075095661,0.005137187501532026,0.004710791996330954,0.00500358350109309,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,power/100,0.004735938011435792,5.5187512771226466e-05,0.004694374998507556,0.004795968750840984,0.004706520514446311,0.004778000002261251,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,power/2,0.004695083509432152,5.3854004363529384e-05,0.004659812497266103,0.004767010010255035,0.0046773954964010045,0.004721541510662064,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,return/bounded/k-10,0.00017718749586492777,1.2709933798760176e-06,0.00017612524970900267,0.00018039548740489408,0.0001765830093063414,0.00017843749083112925,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,return/bounded/k-100,0.001709333504550159,1.6521007637493312e-05,0.0016961974979494698,0.0018163857603212819,0.0016983944191451884,0.0017667710199020803,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,stationary,0.0038943330000620335,2.5125991669483483e-05,0.003835697745671496,0.003911697240255307,0.0038629585033049807,0.003907958001946099,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,structure/classes-cold,0.0016726250032661483,3.083300543949008e-05,0.0016523437443538569,0.0017082604972529225,0.0016636874788673595,0.0017076460062526166,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,structure/classes-lifecycle,0.0144732705084607,0.00014756200835108757,0.014297916248324327,0.014513208509015385,0.01431833348760847,0.014498563003144227,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,structure/classes-warm/access,2.1680624777218328e-07,8.688031812198332e-10,2.162968499760609e-07,2.1789794991491362e-07,2.1636454912368208e-07,2.1772715117549524e-07,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,structure/classes-warm/consumed,5.631204198289197e-06,1.3145848060958217e-08,5.617186476592906e-06,5.640850000781939e-06,5.61891045072116e-06,5.6393749982817095e-06,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,structure/irreducible-cold,0.0016749165079090744,8.709001122042537e-06,0.0016683127323631197,0.001686041257926263,0.0016708031143934932,0.001684500020928681,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,structure/irreducible-warm,2.2553544986294584e-07,1.1542011634446681e-09,2.2493959913845175e-07,2.3880312510300424e-07,2.2506864850583954e-07,2.3298960004467517e-07,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,visits/bounded-expectation/k-10,9.74999857135117e-05,1.0625080903992057e-06,9.643775410950184e-05,9.852101356955245e-05,9.660448995418847e-05,9.829149348661304e-05,30 +pydtmc,absorbing-n0100-s31415,absorbing,100,31415,visits/bounded-expectation/k-100,0.00022762500157114118,2.145985490642488e-06,0.00022507300309371203,0.00022910424740985036,0.0002254169958177954,0.000228749995585531,30 +pydtmc,absorbing-n0250-s01729,absorbing,250,1729,absorption-time,0.025949354501790367,0.00010072850272990763,0.025503281256533228,0.026040302494948264,0.02573216699238401,0.026016791511210613,30 +pydtmc,absorbing-n0250-s01729,absorbing,250,1729,absorption/probabilities,0.026426103999256156,0.00011418749636504799,0.026316343748476356,0.026535437493294012,0.026379167014965788,0.026524812492425554,30 +pydtmc,absorbing-n0250-s01729,absorbing,250,1729,construction/public-consumed,0.07795572900795378,0.00038283348840195686,0.07697535425540991,0.07828196926129749,0.07771491701714694,0.07816616649506614,30 +pydtmc,absorbing-n0250-s01729,absorbing,250,1729,evolution/k-10,0.00040102099592331797,4.749992513097823e-06,0.00039609401574125513,0.0004052502481499687,0.00039804149128030986,0.0004042289947392419,30 +pydtmc,absorbing-n0250-s01729,absorbing,250,1729,evolution/k-100,0.0013245419831946492,9.228999260812998e-06,0.0013180527603253722,0.0013360840093810111,0.0013206875009927899,0.0013325834879651666,30 +pydtmc,absorbing-n0250-s01729,absorbing,250,1729,evolution/one-step,0.000314188000629656,6.041489541530609e-06,0.0003086877622990869,0.0003201039944542572,0.00031083301291801035,0.00031622951792087406,30 +pydtmc,absorbing-n0250-s01729,absorbing,250,1729,fundamental-matrix,0.026081582996994257,0.0001690005010459572,0.025965093991544563,0.026300416742742527,0.02600497931962309,0.026207437491393648,30 +pydtmc,absorbing-n0250-s01729,absorbing,250,1729,hitting-probability/cold-all-states,0.011797624989412725,2.724997466430068e-05,0.011760218745621387,0.011812478995125275,0.011764916504034773,0.011808541996288113,30 +pydtmc,absorbing-n0250-s01729,absorbing,250,1729,hitting-time/cold-all-states,0.023464166501071304,3.962499613407999e-05,0.02341761449497426,0.023498687500250526,0.023424832994351164,0.023494249981013127,30 +pydtmc,absorbing-n0250-s01729,absorbing,250,1729,occupation-matrix,0.5244045414874563,0.0040609580028103665,0.5198178232312785,0.5281723752559628,0.5212291664938675,0.5277050419972511,30 +pydtmc,absorbing-n0250-s01729,absorbing,250,1729,power/10,0.02910768699075561,0.0002221460163127631,0.028900343997520395,0.029333072750887368,0.028949458021088503,0.029321708483621478,30 +pydtmc,absorbing-n0250-s01729,absorbing,250,1729,power/100,0.029313979001017287,0.00024472900258842856,0.029117708501871675,0.029656562241143547,0.029178875003708526,0.029555270986747928,30 +pydtmc,absorbing-n0250-s01729,absorbing,250,1729,power/2,0.028631479508476332,0.00027216700254939497,0.02835459374182392,0.028889271496154834,0.02844708351767622,0.028841125502367504,30 +pydtmc,absorbing-n0250-s01729,absorbing,250,1729,stationary,0.023449771499144845,5.7083991123363376e-05,0.02341838499705773,0.023537426757684443,0.02342370849510189,0.023505271004978567,30 +pydtmc,absorbing-n0250-s01729,absorbing,250,1729,structure/classes-cold,0.010269520993460901,3.174999437760562e-05,0.010227353770460468,0.010282457762514241,0.010237770999083295,0.010277208988554776,30 +pydtmc,absorbing-n0250-s01729,absorbing,250,1729,structure/classes-lifecycle,0.09019822951813694,0.0004729375068563968,0.08986654198815813,0.09118234401103109,0.09003954149375204,0.09063783299643546,30 +pydtmc,absorbing-n0250-s01729,absorbing,250,1729,structure/classes-warm/access,2.1632709976984187e-07,5.603986210189747e-10,2.1585522408713586e-07,2.1691565052606168e-07,2.1597089944407343e-07,2.1687289990950376e-07,30 +pydtmc,absorbing-n0250-s01729,absorbing,250,1729,structure/classes-warm/consumed,1.357621869974537e-05,1.9708350009749355e-08,1.3490091626590585e-05,1.3594728175667115e-05,1.3539731249329633e-05,1.358398955053417e-05,30 +pydtmc,absorbing-n0250-s01729,absorbing,250,1729,structure/irreducible-cold,0.010244750010315329,3.2708499929867685e-05,0.009957416506949812,0.010265520752000157,0.010095771009218879,0.010258375506964512,30 +pydtmc,absorbing-n0250-s01729,absorbing,250,1729,structure/irreducible-warm,2.2291464993031696e-07,3.3130199881271303e-10,2.2278854958130977e-07,2.248646254884079e-07,2.2280830016825348e-07,2.2470830008387567e-07,30 +pydtmc,absorbing-n0250-s02718,absorbing,250,2718,absorption-time,0.025983186991652474,0.00015593749412801117,0.025873521255562082,0.02636579200043343,0.025904916998115368,0.02629635451012291,30 +pydtmc,absorbing-n0250-s02718,absorbing,250,2718,absorption/probabilities,0.026456979496288113,8.447948493994772e-05,0.026367656486399937,0.026520448001974728,0.026383979522506706,0.02650947899383027,30 +pydtmc,absorbing-n0250-s02718,absorbing,250,2718,construction/public-consumed,0.07759372900181916,0.00022829198860563338,0.07688771875109524,0.07772093749372289,0.07725856250908691,0.07766393751080614,30 +pydtmc,absorbing-n0250-s02718,absorbing,250,2718,evolution/k-10,0.00040739601536188275,7.979499059729278e-06,0.00039889576146379113,0.0004139380034757778,0.0004023104022053303,0.0004123335093026981,30 +pydtmc,absorbing-n0250-s02718,absorbing,250,2718,evolution/k-100,0.0013217704981798306,7.021008059382439e-06,0.001315531502768863,0.0013298124977154657,0.001317853995715268,0.0013280625134939328,30 +pydtmc,absorbing-n0250-s02718,absorbing,250,2718,evolution/one-step,0.0003126454830635339,9.291485184803605e-06,0.00030504100141115487,0.0003306044964119792,0.00030729197897017,0.0003198749909643084,30 +pydtmc,absorbing-n0250-s02718,absorbing,250,2718,fundamental-matrix,0.02618133299984038,0.00013772900274489075,0.02603100000123959,0.026212906508590095,0.026064103993121535,0.02620495849987492,30 +pydtmc,absorbing-n0250-s02718,absorbing,250,2718,hitting-probability/cold-all-states,0.011807853996288031,3.21039988193661e-05,0.011771197488997132,0.011825103749288246,0.011775958511861973,0.011816250014817342,30 +pydtmc,absorbing-n0250-s02718,absorbing,250,2718,hitting-time/cold-all-states,0.023520604008808732,3.724951238837093e-05,0.023485302248445805,0.023567698517581448,0.023504125492763706,0.023554624989628792,30 +pydtmc,absorbing-n0250-s02718,absorbing,250,2718,occupation-matrix,0.5254759789968375,0.0037314585060812533,0.5226454794901656,0.5292786562495166,0.5243556665081996,0.5285866875055945,30 +pydtmc,absorbing-n0250-s02718,absorbing,250,2718,power/10,0.029916999992565252,0.0010101250081788749,0.028995489512453787,0.032031843504228164,0.02922093750385102,0.03107727100723423,30 +pydtmc,absorbing-n0250-s02718,absorbing,250,2718,power/100,0.029769999484415166,9.056201088242233e-05,0.029683073233172763,0.029856291504984256,0.02971083349257242,0.029831728999852203,30 +pydtmc,absorbing-n0250-s02718,absorbing,250,2718,power/2,0.028565416010678746,0.00017710351676214486,0.028387656246195547,0.028728531004162505,0.028445291507523507,0.028643041994655505,30 +pydtmc,absorbing-n0250-s02718,absorbing,250,2718,stationary,0.023533208499429747,0.00021652100258506835,0.023304729009396397,0.023715666997304652,0.023380791491945274,0.023649916023714468,30 +pydtmc,absorbing-n0250-s02718,absorbing,250,2718,structure/classes-cold,0.010305562493158504,4.5020991819910705e-05,0.010262760762998369,0.010349375501391478,0.010283145995344967,0.010331604004022665,30 +pydtmc,absorbing-n0250-s02718,absorbing,250,2718,structure/classes-lifecycle,0.09113787500245962,0.0009966460056602955,0.09013790623430395,0.0920991669918294,0.090417500003241,0.09203968700603582,30 +pydtmc,absorbing-n0250-s02718,absorbing,250,2718,structure/classes-warm/access,2.18108351691626e-07,2.7354501071386122e-09,2.1607919843518175e-07,2.2116557593108154e-07,2.172187509131618e-07,2.200950371843646e-07,30 +pydtmc,absorbing-n0250-s02718,absorbing,250,2718,structure/classes-warm/consumed,1.3594556250609456e-05,2.5552049919499404e-08,1.3524488600523908e-05,1.3615456299885408e-05,1.3579839549493045e-05,1.3611102099821438e-05,30 +pydtmc,absorbing-n0250-s02718,absorbing,250,2718,structure/irreducible-cold,0.010222249504295178,0.00010089599527418613,0.01011396852118196,0.010305676740244962,0.010165444484664476,0.01027327099291142,30 +pydtmc,absorbing-n0250-s02718,absorbing,250,2718,structure/irreducible-warm,2.2362705058185382e-07,1.1750016710720823e-09,2.228833494882565e-07,2.262312249513343e-07,2.2316459944704546e-07,2.2530420101247728e-07,30 +pydtmc,absorbing-n0250-s31415,absorbing,250,31415,absorption-time,0.02592645850381814,0.00035089600714854896,0.025605614740925375,0.026435656494868454,0.025704104016767815,0.026340063006500714,30 +pydtmc,absorbing-n0250-s31415,absorbing,250,31415,absorption/probabilities,0.02651616650109645,0.00021908349299337715,0.0263587289955467,0.026833520765649155,0.026384749988210388,0.026675095310565666,30 +pydtmc,absorbing-n0250-s31415,absorbing,250,31415,construction/public-consumed,0.0790128744993126,0.0004591670003719628,0.07870823924895376,0.07993544848432066,0.07875950000016019,0.07956533299875446,30 +pydtmc,absorbing-n0250-s31415,absorbing,250,31415,evolution/k-10,0.000422562996391207,1.0853997082449496e-05,0.0004142815014347434,0.00043763525172835216,0.0004164995043538511,0.0004316664853831753,30 +pydtmc,absorbing-n0250-s31415,absorbing,250,31415,evolution/k-100,0.0013356669951463118,1.2021017028018832e-05,0.001325948273006361,0.0013502705114660785,0.001328521000687033,0.0013469375116983429,30 +pydtmc,absorbing-n0250-s31415,absorbing,250,31415,evolution/one-step,0.00034697900991886854,2.1854008082300425e-05,0.00032714573899284005,0.0003722712499438785,0.00033214599534403533,0.0003674374893307686,30 +pydtmc,absorbing-n0250-s31415,absorbing,250,31415,fundamental-matrix,0.026164645518292673,9.950049570761621e-05,0.02595397898403462,0.02625585401983699,0.02612714600400068,0.0262280098755582,30 +pydtmc,absorbing-n0250-s31415,absorbing,250,31415,hitting-probability/cold-all-states,0.011826604008092545,1.6812991816550493e-05,0.011803854227764532,0.011838729013106786,0.01181612501386553,0.011833833006676286,30 +pydtmc,absorbing-n0250-s31415,absorbing,250,31415,hitting-time/cold-all-states,0.023532124992925674,8.214550325646996e-05,0.023451718734577298,0.023621822518180124,0.023468708488508128,0.023584874492371455,30 +pydtmc,absorbing-n0250-s31415,absorbing,250,31415,occupation-matrix,0.5268472289899364,0.0015677920018788427,0.5254449057465536,0.5283541250028065,0.525834666492301,0.5276094517659659,30 +pydtmc,absorbing-n0250-s31415,absorbing,250,31415,power/10,0.029228687490103766,0.0001736044796416536,0.029089885494613554,0.029478343996743206,0.029129354006727226,0.02938322898990009,30 +pydtmc,absorbing-n0250-s31415,absorbing,250,31415,power/100,0.029597916989587247,0.00017147949256468564,0.029456802498316392,0.029880083246098366,0.02954352745655342,0.029723042011028156,30 +pydtmc,absorbing-n0250-s31415,absorbing,250,31415,power/2,0.028746854499331675,0.00010110400035046041,0.028675947760348208,0.029011135004111566,0.028680896008154377,0.028922249999595806,30 +pydtmc,absorbing-n0250-s31415,absorbing,250,31415,stationary,0.023456812516087666,0.00011506202281452715,0.023299573003896512,0.0234963959956076,0.023319708488998003,0.023482667005737312,30 +pydtmc,absorbing-n0250-s31415,absorbing,250,31415,structure/classes-cold,0.010418958496302366,2.270800177939236e-05,0.010404427492176183,0.010465135746926535,0.010408561996882781,0.010446166488691233,30 +pydtmc,absorbing-n0250-s31415,absorbing,250,31415,structure/classes-lifecycle,0.09131425000668969,0.0005922499985899776,0.09076967650617007,0.0919867812335724,0.09086545801255852,0.09181974999955855,30 +pydtmc,absorbing-n0250-s31415,absorbing,250,31415,structure/classes-warm/access,2.1538329892791807e-07,8.396527846343936e-10,2.146448263374623e-07,2.1622607673634777e-07,2.1493749954970553e-07,2.1570625103777274e-07,30 +pydtmc,absorbing-n0250-s31415,absorbing,250,31415,structure/classes-warm/consumed,1.3645345850090963e-05,8.173749956767997e-08,1.3570700975105866e-05,1.3807267725496786e-05,1.3586814599693753e-05,1.3719291650340892e-05,30 +pydtmc,absorbing-n0250-s31415,absorbing,250,31415,structure/irreducible-cold,0.01025893799669575,5.066599987912923e-05,0.010219552015769295,0.010331937512091827,0.010227853985270485,0.010292020495398901,30 +pydtmc,absorbing-n0250-s31415,absorbing,250,31415,structure/irreducible-warm,2.2249580069910735e-07,1.1249489034526093e-09,2.2090209895395674e-07,2.2304582453216425e-07,2.2120839857961982e-07,2.2283540019998325e-07,30 +pydtmc,absorbing-n0500-s01729,absorbing,500,1729,absorption-time,0.10172735450032633,0.0004269370110705495,0.1012770940142218,0.10212882225459907,0.10145806199579965,0.10198708399548195,30 +pydtmc,absorbing-n0500-s01729,absorbing,500,1729,absorption/probabilities,0.10284477098321076,0.0003836250107269734,0.10253090674086707,0.10340353100036737,0.1025814374879701,0.10313585399126168,30 +pydtmc,absorbing-n0500-s01729,absorbing,500,1729,construction/public-consumed,0.32385847948899027,0.003260458499426022,0.3214416980044916,0.32721635424968554,0.3219225000066217,0.32666181300010066,30 +pydtmc,absorbing-n0500-s01729,absorbing,500,1729,evolution/k-10,0.0010263959993608296,1.1541997082531452e-05,0.0010195414943154901,0.0010483847581781447,0.0010203124984400347,0.0010378750157542527,30 +pydtmc,absorbing-n0500-s01729,absorbing,500,1729,evolution/k-100,0.004142354504438117,3.266701241955161e-05,0.004119436991459224,0.004237447508785408,0.004126395506318659,0.004197250003926456,30 +pydtmc,absorbing-n0500-s01729,absorbing,500,1729,evolution/one-step,0.0007262080034706742,1.3396012946031988e-05,0.0007141044916352257,0.0007481985085178167,0.0007147290016291663,0.0007351874955929816,30 +pydtmc,absorbing-n0500-s01729,absorbing,500,1729,fundamental-matrix,0.1020134585123742,0.000315792000037618,0.10178041649487568,0.10244098950352054,0.10185627099417616,0.10230220801895484,30 +pydtmc,absorbing-n0500-s01729,absorbing,500,1729,hitting-probability/cold-all-states,0.08648249949328601,0.00022510450799018145,0.0863590937515255,0.08681254200928379,0.08639785401464906,0.08662558349897154,30 +pydtmc,absorbing-n0500-s01729,absorbing,500,1729,hitting-time/cold-all-states,0.1721503124863375,0.0002292294957442209,0.1719735730002867,0.1726779689997784,0.1719902364544396,0.17252106248633936,30 +pydtmc,absorbing-n0500-s01729,absorbing,500,1729,power/10,0.12032666651066393,0.000636666503851302,0.11968906273978064,0.12095144799968693,0.11991441700956784,0.12067066700547002,30 +pydtmc,absorbing-n0500-s01729,absorbing,500,1729,power/100,0.12563160399440676,0.0012421670107869431,0.12485191649466287,0.12700740648870124,0.12519043749489356,0.12623845899361186,30 +pydtmc,absorbing-n0500-s01729,absorbing,500,1729,power/2,0.11838014550448861,0.0002206250064773485,0.11819561398442602,0.11867126075230772,0.11828754100133665,0.11858875049802009,30 +pydtmc,absorbing-n0500-s01729,absorbing,500,1729,stationary,0.09271935401193332,0.0008212290122173727,0.09209846873272909,0.09372684423578903,0.09240294826740864,0.09327629150357097,30 +pydtmc,absorbing-n0500-s01729,absorbing,500,1729,structure/classes-cold,0.040996145995450206,0.0001083544921129942,0.04088356225838652,0.041094187487033196,0.040904729001340456,0.04108739600633271,30 +pydtmc,absorbing-n0500-s01729,absorbing,500,1729,structure/classes-lifecycle,0.37592920850147493,0.003692999991471879,0.37259231300413376,0.38028561525425175,0.3732337079854915,0.3776887084968621,30 +pydtmc,absorbing-n0500-s01729,absorbing,500,1729,structure/classes-warm/access,2.1704789833165705e-07,6.895992555655395e-10,2.166562495403923e-07,2.3038017534418033e-07,2.167041995562613e-07,2.2390204976545648e-07,30 +pydtmc,absorbing-n0500-s01729,absorbing,500,1729,structure/classes-warm/consumed,2.8848147900134792e-05,8.681300096212725e-09,2.8840663548908197e-05,2.885788539861096e-05,2.884514374891296e-05,2.8855160450621045e-05,30 +pydtmc,absorbing-n0500-s01729,absorbing,500,1729,structure/irreducible-cold,0.04090370850462932,6.335449870675802e-05,0.04085915599716827,0.041051010754017625,0.04086857913789572,0.040995624993229285,30 +pydtmc,absorbing-n0500-s01729,absorbing,500,1729,structure/irreducible-warm,2.2439795138780027e-07,8.771006832830496e-10,2.2349372447934e-07,2.250739751616493e-07,2.2379169968189672e-07,2.2488124959636479e-07,30 +pydtmc,absorbing-n0500-s02718,absorbing,500,2718,absorption-time,0.10146754149172921,0.00041162500565405935,0.10071738575061318,0.10174876049859449,0.10107531299581751,0.1016456250072224,30 +pydtmc,absorbing-n0500-s02718,absorbing,500,2718,absorption/probabilities,0.10230662500543986,0.0005964584997855127,0.1018502917359001,0.10402502076613018,0.10193499999877531,0.10371681200922467,30 +pydtmc,absorbing-n0500-s02718,absorbing,500,2718,construction/public-consumed,0.3209117079968564,0.0025187710125464946,0.3185482809858513,0.3230033645086223,0.3200140624976484,0.3218340102517686,30 +pydtmc,absorbing-n0500-s02718,absorbing,500,2718,evolution/k-10,0.0010439165052957833,1.9479499314911664e-05,0.0010274892702000216,0.0010783230027300306,0.0010356249986216426,0.0010605840070638806,30 +pydtmc,absorbing-n0500-s02718,absorbing,500,2718,evolution/k-100,0.004152291498030536,2.489550388418138e-05,0.0041294585025752895,0.004185041005257517,0.004132228510570712,0.004163125006016344,30 +pydtmc,absorbing-n0500-s02718,absorbing,500,2718,evolution/one-step,0.0007355830020969734,2.208250225521624e-05,0.0007206665104604326,0.0007696142711210996,0.000725562495063059,0.0007584164995932952,30 +pydtmc,absorbing-n0500-s02718,absorbing,500,2718,fundamental-matrix,0.10141016700072214,0.00040264648851007223,0.10110241648362717,0.10202721925452352,0.10118262500327546,0.10170529149763752,30 +pydtmc,absorbing-n0500-s02718,absorbing,500,2718,hitting-probability/cold-all-states,0.08649254198826384,0.0003448335046414286,0.08629099999234313,0.08695252101460937,0.0864108959940495,0.08685799999511801,30 +pydtmc,absorbing-n0500-s02718,absorbing,500,2718,hitting-time/cold-all-states,0.17370027049037162,0.0009632084838813171,0.1729196349842823,0.17693315625365358,0.17303375000483356,0.1753699164983118,30 +pydtmc,absorbing-n0500-s02718,absorbing,500,2718,power/10,0.12087464549404103,0.0004650004848372191,0.12050635450577829,0.12135980200400809,0.12060472900338937,0.12121318798745051,30 +pydtmc,absorbing-n0500-s02718,absorbing,500,2718,power/100,0.12470156249764841,0.000937083488679491,0.12403133324551163,0.12565094798628706,0.12417225001263432,0.1252504590083845,30 +pydtmc,absorbing-n0500-s02718,absorbing,500,2718,power/2,0.11763554149365518,0.0006637920159846544,0.1171363335015485,0.1183374374959385,0.11739941700943746,0.11813902051653713,30 +pydtmc,absorbing-n0500-s02718,absorbing,500,2718,stationary,0.09309345851943363,0.0005226665089139715,0.0927507707674522,0.09363177100021858,0.09289587449165992,0.09355072950711474,30 +pydtmc,absorbing-n0500-s02718,absorbing,500,2718,structure/classes-cold,0.04123952050576918,0.0001308330101892352,0.04115007274958771,0.041454240010352805,0.04117837501689792,0.041397624983801506,30 +pydtmc,absorbing-n0500-s02718,absorbing,500,2718,structure/classes-lifecycle,0.3730441454972606,0.003422020497964695,0.3706646667342284,0.37759826050751144,0.37124504199891817,0.37610752100590616,30 +pydtmc,absorbing-n0500-s02718,absorbing,500,2718,structure/classes-warm/access,2.1562499896390363e-07,1.174998760689044e-09,2.1490942453965545e-07,2.1962292448733932e-07,2.150813001208007e-07,2.1767500002169981e-07,30 +pydtmc,absorbing-n0500-s02718,absorbing,500,2718,structure/classes-warm/consumed,2.8796181299549063e-05,1.0775050031952503e-08,2.8780279176135083e-05,2.880192917509703e-05,2.8783402100089006e-05,2.880062500044005e-05,30 +pydtmc,absorbing-n0500-s02718,absorbing,500,2718,structure/irreducible-cold,0.04088345849595498,0.00022893700224813074,0.04068410398031119,0.041114646242931485,0.04078597899933811,0.04107342640381831,30 +pydtmc,absorbing-n0500-s02718,absorbing,500,2718,structure/irreducible-warm,2.2309164924081413e-07,1.2499993317760533e-09,2.2166352573549373e-07,2.2377500135917215e-07,2.219979010988027e-07,2.2360000002663582e-07,30 +pydtmc,absorbing-n0500-s31415,absorbing,500,31415,absorption-time,0.10021316650090739,0.0005300000048009679,0.09982782349106856,0.10079454150400124,0.0999495415162528,0.10070824949070811,30 +pydtmc,absorbing-n0500-s31415,absorbing,500,31415,absorption/probabilities,0.10232583399920259,0.0005849165027029812,0.10086684350244468,0.10268358350003837,0.10151845849759411,0.10257668698613998,30 +pydtmc,absorbing-n0500-s31415,absorbing,500,31415,construction/public-consumed,0.31899458351836074,0.0034590210125315934,0.31578164549137,0.32652675000281306,0.31608774950873336,0.3201872499921592,30 +pydtmc,absorbing-n0500-s31415,absorbing,500,31415,evolution/k-10,0.0010631039913278073,1.966700074262917e-05,0.0010499484851607122,0.0010870417390833609,0.0010574579937383533,0.0010804170015035197,30 +pydtmc,absorbing-n0500-s31415,absorbing,500,31415,evolution/k-100,0.004132020505494438,1.9104001694358885e-05,0.004119385492231231,0.004179083269264083,0.00412093750492204,0.004167791485087946,30 +pydtmc,absorbing-n0500-s31415,absorbing,500,31415,evolution/one-step,0.0007356874994002283,9.54199640545994e-06,0.0007268232511705719,0.000745531746360939,0.0007291444435395533,0.0007397499866783619,30 +pydtmc,absorbing-n0500-s31415,absorbing,500,31415,fundamental-matrix,0.10143243700440507,0.0002761879877652973,0.10117029174580239,0.10177803175611189,0.10132912499830127,0.10168029149645008,30 +pydtmc,absorbing-n0500-s31415,absorbing,500,31415,hitting-probability/cold-all-states,0.08641414549492765,0.00013697899703402072,0.08619582273968263,0.08650085374392802,0.08626137500687037,0.08646833300008439,30 +pydtmc,absorbing-n0500-s31415,absorbing,500,31415,hitting-time/cold-all-states,0.17226043750997633,0.0003103960189037025,0.1719793855008902,0.1727908542525256,0.17202766650007106,0.17262135399505496,30 +pydtmc,absorbing-n0500-s31415,absorbing,500,31415,power/10,0.120363666996127,0.0006425004976335913,0.11995228150044568,0.12109968774893787,0.12007281249680091,0.12097629201889504,30 +pydtmc,absorbing-n0500-s31415,absorbing,500,31415,power/100,0.12459281249903142,0.0009186870011035353,0.12408206300460733,0.12593016699975124,0.12427102100627962,0.12559306249022484,30 +pydtmc,absorbing-n0500-s31415,absorbing,500,31415,power/2,0.11995885448413901,0.0008269170066341758,0.11966813549952349,0.12162248925596941,0.11980777101416606,0.12087610449816566,30 +pydtmc,absorbing-n0500-s31415,absorbing,500,31415,stationary,0.09319304199016187,0.00040647899731993675,0.09288696849398548,0.09363874950940954,0.09298462499282323,0.09355874950415455,30 +pydtmc,absorbing-n0500-s31415,absorbing,500,31415,structure/classes-cold,0.041042437514988706,0.0001119164953706786,0.04069542698562145,0.04113912475440884,0.04089056249358691,0.041103499999735504,30 +pydtmc,absorbing-n0500-s31415,absorbing,500,31415,structure/classes-lifecycle,0.369141937509994,0.0030466875032288954,0.3662323225144064,0.3725241872307379,0.3675269169907551,0.37143275000562426,30 +pydtmc,absorbing-n0500-s31415,absorbing,500,31415,structure/classes-warm/access,2.1632085117744283e-07,1.1604512110352545e-09,2.156051734345965e-07,2.1774787455797196e-07,2.1587285009445622e-07,2.1736869966844096e-07,30 +pydtmc,absorbing-n0500-s31415,absorbing,500,31415,structure/classes-warm/consumed,2.884857295139227e-05,1.445414964109641e-08,2.883389477574383e-05,2.8862232275423595e-05,2.8839549999975135e-05,2.8860460451687688e-05,30 +pydtmc,absorbing-n0500-s31415,absorbing,500,31415,structure/irreducible-cold,0.04085031300201081,0.00029198000265751034,0.040579073487606365,0.04134540626546368,0.040666562505066395,0.04129731250577606,30 +pydtmc,absorbing-n0500-s31415,absorbing,500,31415,structure/irreducible-warm,2.2223954874789342e-07,6.520989700220481e-10,2.2157912462716924e-07,2.2271252455539073e-07,2.2166669950820507e-07,2.225125004770234e-07,30 +pydtmc,absorbing-n1000-s01729,absorbing,1000,1729,construction/public-consumed,1.3240627914929064,0.011868895511724986,1.3126986874776776,1.3354152182510006,1.322299354011193,1.3295021874946542,30 +pydtmc,absorbing-n1000-s01729,absorbing,1000,1729,evolution/k-10,0.00363381250645034,7.968751015141606e-05,0.003569458487618249,0.0037398749991552904,0.0036102499871049076,0.003690603989525698,30 +pydtmc,absorbing-n1000-s01729,absorbing,1000,1729,evolution/k-100,0.020358084002509713,0.00040027100476436317,0.020106906493310817,0.02084627051226562,0.020220125006744638,0.020788750014617108,30 +pydtmc,absorbing-n1000-s01729,absorbing,1000,1729,evolution/one-step,0.0019306044996483251,6.118699093349278e-05,0.001884156241430901,0.0019994894973933697,0.0018913749954663217,0.0019898959872080013,30 +pydtmc,absorbing-n1000-s01729,absorbing,1000,1729,structure/classes-cold,0.164497729492723,0.00039343751268461347,0.16412695823964896,0.16487111450987868,0.16432837501633912,0.16475710400845855,30 +pydtmc,absorbing-n1000-s01729,absorbing,1000,1729,structure/classes-lifecycle,1.5258679585094796,0.005817833502078429,1.518783770246955,1.531097895502171,1.5206895415176405,1.5294416250108043,30 +pydtmc,absorbing-n1000-s01729,absorbing,1000,1729,structure/classes-warm/access,2.1575415012193844e-07,6.895992555655528e-10,2.1504482356249353e-07,2.1641252460540273e-07,2.1518124995054676e-07,2.1615415025735276e-07,30 +pydtmc,absorbing-n1000-s01729,absorbing,1000,1729,structure/classes-warm/consumed,5.930612079973799e-05,2.9645799077113362e-08,5.928212602448184e-05,5.934468857376487e-05,5.928994380083168e-05,5.9329477099527136e-05,30 +pydtmc,absorbing-n1000-s01729,absorbing,1000,1729,structure/irreducible-cold,0.16419824998592958,0.00021447949984576553,0.16378712448931765,0.16429812501155538,0.16388712500338443,0.16427560400916263,30 +pydtmc,absorbing-n1000-s01729,absorbing,1000,1729,structure/irreducible-warm,2.2132289886940272e-07,9.270996088162011e-10,2.2051979976822622e-07,2.2226977453101426e-07,2.2067709942348302e-07,2.22181249409914e-07,30 +pydtmc,absorbing-n1000-s02718,absorbing,1000,2718,construction/public-consumed,1.3316185625008075,0.013180333495256491,1.3147039889954613,1.3389548334889696,1.3225570625072578,1.3354185414937092,30 +pydtmc,absorbing-n1000-s02718,absorbing,1000,2718,evolution/k-10,0.0036631869879784063,0.00013068801490589976,0.003528510242176708,0.0037800107602379285,0.0035653119994094595,0.0037515000003622845,30 +pydtmc,absorbing-n1000-s02718,absorbing,1000,2718,evolution/k-100,0.020415229504578747,0.00011912449554074556,0.020285864251491148,0.020506885506620165,0.020329728999058716,0.020453334000194445,30 +pydtmc,absorbing-n1000-s02718,absorbing,1000,2718,evolution/one-step,0.0019201249815523624,6.427097832784057e-05,0.0018681980145629495,0.0021150832399143837,0.0018856249807868153,0.0019719062467629554,30 +pydtmc,absorbing-n1000-s02718,absorbing,1000,2718,structure/classes-cold,0.16513516650593374,0.0006445629987865686,0.16429329199308995,0.16567595848755445,0.1645690419827588,0.16545818749000318,30 +pydtmc,absorbing-n1000-s02718,absorbing,1000,2718,structure/classes-lifecycle,1.5211265414982336,0.011847145506180823,1.5109410727454815,1.5338786142601748,1.512331959005678,1.5306629170081578,30 +pydtmc,absorbing-n1000-s02718,absorbing,1000,2718,structure/classes-warm/access,2.1550210076384247e-07,8.292001439258511e-10,2.1488957572728396e-07,2.1727394923800603e-07,2.1508750214707107e-07,2.1662714862031863e-07,30 +pydtmc,absorbing-n1000-s02718,absorbing,1000,2718,structure/classes-warm/consumed,5.933291664987337e-05,5.3060401114635956e-08,5.9290864624199456e-05,5.970454062553472e-05,5.929800409940072e-05,5.9517085399420465e-05,30 +pydtmc,absorbing-n1000-s02718,absorbing,1000,2718,structure/irreducible-cold,0.16600610449677333,0.0005723130016122013,0.1654261247458635,0.16649451025296003,0.16568039549747482,0.16623372948379256,30 +pydtmc,absorbing-n1000-s02718,absorbing,1000,2718,structure/irreducible-warm,2.2028125094948337e-07,4.3750042095780525e-10,2.1980937526677736e-07,2.2065102602937258e-07,2.1997084986651316e-07,2.2054585111618508e-07,30 +pydtmc,absorbing-n1000-s31415,absorbing,1000,31415,construction/public-consumed,1.3627606039954117,0.02593699999852106,1.3435895205038833,1.4036208539910149,1.353239999996731,1.401747500509373,30 +pydtmc,absorbing-n1000-s31415,absorbing,1000,31415,evolution/k-10,0.003981937508797273,8.579151472076774e-05,0.00393263524165377,0.00418300049204845,0.003951916500227526,0.0041037290066014975,30 +pydtmc,absorbing-n1000-s31415,absorbing,1000,31415,evolution/k-100,0.021041291489382274,0.00031202100217342377,0.02069530174776446,0.021331978736270685,0.02078927049296908,0.02115610399050638,30 +pydtmc,absorbing-n1000-s31415,absorbing,1000,31415,evolution/one-step,0.002358062512939796,0.00023774997680447996,0.002141801996913273,0.00259855199692538,0.00219912501052022,0.002548604490584694,30 +pydtmc,absorbing-n1000-s31415,absorbing,1000,31415,structure/classes-cold,0.1650975414813729,0.0007350829837378114,0.16436072925716871,0.16573871874425095,0.16461625002557412,0.16538889550429303,30 +pydtmc,absorbing-n1000-s31415,absorbing,1000,31415,structure/classes-lifecycle,1.53064812500088,0.016525937477126718,1.5102771670135553,1.5397535515148775,1.524149282815415,1.5380761874839664,30 +pydtmc,absorbing-n1000-s31415,absorbing,1000,31415,structure/classes-warm/access,2.1837085078004747e-07,1.2208518455736256e-09,2.1753744804300369e-07,2.2043754797778093e-07,2.1814794890815392e-07,2.1920409926678986e-07,30 +pydtmc,absorbing-n1000-s31415,absorbing,1000,31415,structure/classes-warm/consumed,5.9453674999531355e-05,1.0276874963892471e-07,5.9358040650840844e-05,5.962964482532697e-05,5.937336459901416e-05,5.954146665026201e-05,30 +pydtmc,absorbing-n1000-s31415,absorbing,1000,31415,structure/irreducible-cold,0.16439435399661306,0.00041277098353020847,0.1639644790047896,0.16471342700970126,0.16412199950718787,0.1646442500059493,30 +pydtmc,absorbing-n1000-s31415,absorbing,1000,31415,structure/irreducible-warm,2.2426034993259235e-07,7.562499376945234e-10,2.235978754470125e-07,2.251406229333952e-07,2.237353997770697e-07,2.2482499916804954e-07,30 +pydtmc,dense-n0010-s01729,dense,10,1729,construction/public-consumed,0.00043525049841264263,1.1436997738201171e-05,0.0004280107496015262,0.00045008275264990516,0.0004326250054873526,0.0004466874961508438,30 +pydtmc,dense-n0010-s01729,dense,10,1729,evolution/k-10,5.4771000577602535e-05,2.354507159907371e-06,5.305225568008609e-05,5.7989505876321346e-05,5.366600817069411e-05,5.710450204787776e-05,30 +pydtmc,dense-n0010-s01729,dense,10,1729,evolution/k-100,0.00026954150234814733,6.020505679771304e-06,0.000263614743744256,0.00027543725445866585,0.00026502100081415847,0.00027304149261908606,30 +pydtmc,dense-n0010-s01729,dense,10,1729,evolution/one-step,3.5520999517757446e-05,3.583001671358943e-06,3.317700247862376e-05,4.0875242120819166e-05,3.4042008337564766e-05,3.891649976139888e-05,30 +pydtmc,dense-n0010-s01729,dense,10,1729,finite-time/n-step/k-10,5.537550168810412e-05,1.8329956219531596e-06,5.335424793884158e-05,5.7114750234177336e-05,5.372949817683548e-05,5.685399810317904e-05,30 +pydtmc,dense-n0010-s01729,dense,10,1729,finite-time/n-step/k-100,0.0002675835057743825,4.979505320079625e-06,0.0002637287507241126,0.0002773234919004608,0.0002649943129654275,0.00027327100542606786,30 +pydtmc,dense-n0010-s01729,dense,10,1729,finite-time/observation/k-10,5.241650069365278e-05,1.583510311320424e-06,5.1770504796877503e-05,5.89477494941093e-05,5.21039983141236e-05,5.8290999731980264e-05,30 +pydtmc,dense-n0010-s01729,dense,10,1729,finite-time/observation/k-100,0.00027647950628306717,5.2084942581132054e-06,0.00027214600413572043,0.00028802074302802794,0.00027285449323244393,0.0002815414991346188,30 +pydtmc,dense-n0010-s01729,dense,10,1729,finite-time/step,1.0415024007670581e-06,1.2500095181167126e-07,9.57996235229075e-07,1.2394957593642175e-06,9.590003173798323e-07,1.167005393654108e-06,30 +pydtmc,dense-n0010-s01729,dense,10,1729,hitting-probability/cold-all-states,5.004150443710387e-05,3.3124961191788316e-06,4.789550439454615e-05,5.5374999647028744e-05,4.883196670562029e-05,5.249999958323315e-05,30 +pydtmc,dense-n0010-s01729,dense,10,1729,hitting-time/cold-all-states,0.00010135400225408375,5.770503776147962e-06,9.745824718265794e-05,0.00011305200314382091,9.879150456981733e-05,0.00010902099893428385,30 +pydtmc,dense-n0010-s01729,dense,10,1729,hitting/bounded/at-most/k-10,4.51045052614063e-05,1.4585093595087528e-06,4.361500032246113e-05,4.636475205188617e-05,4.418699973030016e-05,4.5729502744507045e-05,30 +pydtmc,dense-n0010-s01729,dense,10,1729,hitting/bounded/at-most/k-100,0.0003778750033234246,8.583498129155487e-06,0.0003457500097283628,0.00038027099799364805,0.0003554165086825378,0.0003791665003518574,30 +pydtmc,dense-n0010-s01729,dense,10,1729,hitting/bounded/exact/k-10,4.53335014753975e-05,8.540009730495512e-07,4.454200097825378e-05,4.6198001655284315e-05,4.4729007640853524e-05,4.5812499593012035e-05,30 +pydtmc,dense-n0010-s01729,dense,10,1729,hitting/bounded/exact/k-100,0.0003809789923252538,1.4875004126224667e-05,0.0003559792421583552,0.00038969774686847813,0.0003674789986689575,0.00038702623387507626,30 +pydtmc,dense-n0010-s01729,dense,10,1729,hitting/bounded/greater-than/k-10,4.491699655773118e-05,1.2710006558336318e-06,4.3749751057475805e-05,4.650000118999742e-05,4.4103995605837554e-05,4.61664967588149e-05,30 +pydtmc,dense-n0010-s01729,dense,10,1729,hitting/bounded/greater-than/k-100,0.0003450834992690943,9.04199987417087e-06,0.0003407397525734268,0.00038651075010420755,0.00034291650081286207,0.0003677084969240241,30 +pydtmc,dense-n0010-s01729,dense,10,1729,power/10,0.00033672899735393,7.353992259595543e-06,0.0003318435119581409,0.00035449974893708713,0.0003343544958624989,0.00034477099688956514,30 +pydtmc,dense-n0010-s01729,dense,10,1729,power/100,0.0003420624998398125,1.4999997802078724e-05,0.0003304579913674388,0.0003643022500909865,0.00033187499502673745,0.0003551585030436399,30 +pydtmc,dense-n0010-s01729,dense,10,1729,power/2,0.0003370830017956905,1.1229996744077653e-05,0.00032776024454506114,0.00036336474659037776,0.00033033300132956356,0.00034831299853976816,30 +pydtmc,dense-n0010-s01729,dense,10,1729,race/forward-committor,0.0002737079994403757,5.7704965001903474e-06,0.00026876074480242096,0.00028057299641659483,0.00027012499049305916,0.00027637500897981226,30 +pydtmc,dense-n0010-s01729,dense,10,1729,return/bounded/k-10,4.795799759449437e-05,3.666493284981698e-06,4.391674883663654e-05,5.0583246775204316e-05,4.4479500502347946e-05,4.992012327420524e-05,30 +pydtmc,dense-n0010-s01729,dense,10,1729,return/bounded/k-100,0.000349812995409593,5.1455062930472195e-06,0.00034550000782473944,0.0003551460067683365,0.00034747850440908223,0.0003543544953572564,30 +pydtmc,dense-n0010-s01729,dense,10,1729,return/mean-recurrence,0.00030912500369595364,6.771006155759096e-06,0.0003059587579627987,0.00032326025393558666,0.0003073129992117174,0.00031812500674277544,30 +pydtmc,dense-n0010-s01729,dense,10,1729,simulation/10000,0.08231706250080606,0.0015485000039916486,0.08088155274890596,0.08412313550070394,0.08161991600354668,0.08339618799800519,30 +pydtmc,dense-n0010-s01729,dense,10,1729,simulation/100000,0.8382936459966004,0.021216416505922098,0.8183418335029273,0.8597799375056638,0.8216830415040022,0.8549197505053598,30 +pydtmc,dense-n0010-s01729,dense,10,1729,stationary,9.404149750480428e-05,2.396001946181059e-06,9.163524737232365e-05,9.5927003712859e-05,9.227100235875696e-05,9.483350004302338e-05,30 +pydtmc,dense-n0010-s01729,dense,10,1729,structure/classes-cold,3.814549563685432e-05,1.52099528349936e-06,3.658300556708127e-05,3.944774653064087e-05,3.722900146385655e-05,3.885400656145066e-05,30 +pydtmc,dense-n0010-s01729,dense,10,1729,structure/classes-lifecycle,0.0005104999945615418,2.9687500500585884e-05,0.0004701979996752925,0.0005227082474448252,0.0004883540023001842,0.0005185829941183329,30 +pydtmc,dense-n0010-s01729,dense,10,1729,structure/classes-warm/access,2.2682919952785596e-07,2.7458991098683205e-09,2.2438750020228327e-07,2.305552003235789e-07,2.250333498523105e-07,2.3033754914649762e-07,30 +pydtmc,dense-n0010-s01729,dense,10,1729,structure/classes-warm/consumed,1.0537667003518438e-06,1.7216699779964913e-08,1.024758299536188e-06,1.0628864249156324e-06,1.0318249493138865e-06,1.0613458493025973e-06,30 +pydtmc,dense-n0010-s01729,dense,10,1729,structure/irreducible-cold,3.529200330376625e-05,1.145504938904196e-06,3.467724673100747e-05,3.7510497350012884e-05,3.477100108284503e-05,3.649949940154329e-05,30 +pydtmc,dense-n0010-s01729,dense,10,1729,structure/irreducible-warm,2.413042006082833e-07,1.0093751188833258e-08,2.329843508050544e-07,2.5811772575252693e-07,2.3563977290905315e-07,2.5757709954632446e-07,30 +pydtmc,dense-n0010-s01729,dense,10,1729,visits/bounded-expectation/k-10,2.2520500351674855e-05,1.4170072972774506e-06,2.080150443362072e-05,2.3176744434749708e-05,2.099999983329326e-05,2.2812499082647264e-05,30 +pydtmc,dense-n0010-s01729,dense,10,1729,visits/bounded-expectation/k-100,8.079200051724911e-05,1.5419936971738935e-06,7.918750634416938e-05,8.211474778363481e-05,7.952099258545786e-05,8.17085019662045e-05,30 +pydtmc,dense-n0010-s02718,dense,10,2718,construction/public-consumed,0.00037989600241417065,1.9165017874911427e-06,0.00037892700493102893,0.00038379149555112235,0.00037918699672445655,0.00038207080797292287,30 +pydtmc,dense-n0010-s02718,dense,10,2718,evolution/k-10,5.2916504500899464e-05,1.5415062080137432e-06,5.1260496547911316e-05,5.433299520518631e-05,5.162500019650906e-05,5.389599391492084e-05,30 +pydtmc,dense-n0010-s02718,dense,10,2718,evolution/k-100,0.0002624584885779768,2.4794862838461995e-06,0.00026057249488076195,0.0002650420028658118,0.00026143232717004136,0.0002642499966896139,30 +pydtmc,dense-n0010-s02718,dense,10,2718,evolution/one-step,3.235400072298944e-05,1.4585020835511386e-06,3.1385996408062056e-05,3.3927000913536176e-05,3.166699752910063e-05,3.381299757165834e-05,30 +pydtmc,dense-n0010-s02718,dense,10,2718,finite-time/n-step/k-10,5.77710015932098e-05,4.541492671705782e-06,5.34272548975423e-05,6.209374623722397e-05,5.5145996157079935e-05,5.933298962190747e-05,30 +pydtmc,dense-n0010-s02718,dense,10,2718,finite-time/n-step/k-100,0.00027447949833003804,5.1875103963539004e-06,0.00027232299180468544,0.00028396875495673157,0.0002728540057432838,0.0002795630061882548,30 +pydtmc,dense-n0010-s02718,dense,10,2718,finite-time/observation/k-10,5.622899334412068e-05,5.187488568481058e-06,5.2073246479267254e-05,6.939600643818267e-05,5.3562493121717125e-05,6.315014888969016e-05,30 +pydtmc,dense-n0010-s02718,dense,10,2718,finite-time/observation/k-100,0.0002703749996726401,4.021007043775171e-06,0.00026796874226420186,0.00028677075169980526,0.00026874949980992824,0.00027660400519380346,30 +pydtmc,dense-n0010-s02718,dense,10,2718,finite-time/step,9.590003173798323e-07,6.300251698121428e-08,9.169889381155372e-07,1.0727490007411689e-06,9.169962140731514e-07,1.0210060281679034e-06,30 +pydtmc,dense-n0010-s02718,dense,10,2718,hitting-probability/cold-all-states,5.68750110687688e-05,6.708003638777882e-06,5.223924745223485e-05,6.43439962004777e-05,5.3125004342291504e-05,6.281201058300212e-05,30 +pydtmc,dense-n0010-s02718,dense,10,2718,hitting-time/cold-all-states,9.983300697058439e-05,4.208006430417299e-06,9.688549835118465e-05,0.0001057285007846076,9.774998761713505e-05,0.00010491649300092831,30 +pydtmc,dense-n0010-s02718,dense,10,2718,hitting/bounded/at-most/k-10,5.0020993512589484e-05,3.5420016502030194e-06,4.662499486585148e-05,5.3604249842464924e-05,4.720850120065734e-05,5.3125004342291504e-05,30 +pydtmc,dense-n0010-s02718,dense,10,2718,hitting/bounded/at-most/k-100,0.0003338329988764599,3.478999133221805e-06,0.00033260424970649183,0.00034081250851158984,0.00033326948378089585,0.0003385835007065907,30 +pydtmc,dense-n0010-s02718,dense,10,2718,hitting/bounded/exact/k-10,5.014549969928339e-05,4.770503437612206e-06,4.497924237512052e-05,5.4010492021916434e-05,4.57915011793375e-05,5.3270508942659944e-05,30 +pydtmc,dense-n0010-s02718,dense,10,2718,hitting/bounded/exact/k-100,0.0003361455019330606,2.77049548458308e-06,0.000333260752086062,0.0003382494978723116,0.00033479199919383973,0.00033758350036805496,30 +pydtmc,dense-n0010-s02718,dense,10,2718,hitting/bounded/greater-than/k-10,4.8582995077595115e-05,4.666493623517454e-06,4.64369950350374e-05,5.4927000746829435e-05,4.716700641438365e-05,5.358300404623151e-05,30 +pydtmc,dense-n0010-s02718,dense,10,2718,hitting/bounded/greater-than/k-100,0.0003408539996598847,1.0937008482869714e-05,0.0003371562524989713,0.0003655625077954028,0.0003388959958101623,0.000350645997968968,30 +pydtmc,dense-n0010-s02718,dense,10,2718,power/10,0.00033524999889777973,6.312497134786099e-06,0.00033112500022980385,0.00034878150472650304,0.00033243749930988997,0.0003441942764766281,30 +pydtmc,dense-n0010-s02718,dense,10,2718,power/100,0.00034264599526068196,1.8604005163069814e-05,0.0003242082420911174,0.00036027049645781517,0.0003321670010336675,0.0003575829978217371,30 +pydtmc,dense-n0010-s02718,dense,10,2718,power/2,0.00033404149871785194,5.916503141634166e-06,0.0003265939922130201,0.00033897924367920496,0.0003286874998593703,0.00033668750256765634,30 +pydtmc,dense-n0010-s02718,dense,10,2718,race/forward-committor,0.00030099950527073815,1.752050593495369e-05,0.00028488500538514927,0.00032521874527446926,0.0002872294935514219,0.00031679200765211135,30 +pydtmc,dense-n0010-s02718,dense,10,2718,return/bounded/k-10,4.893800360150635e-05,3.3750038710422814e-06,4.6760495024500415e-05,5.415650230133906e-05,4.7249995986931026e-05,5.3021001804154366e-05,30 +pydtmc,dense-n0010-s02718,dense,10,2718,return/bounded/k-100,0.0003377504981472157,3.7915015127509832e-06,0.0003337602465762757,0.0003410202480154112,0.00033552099193912,0.0003407084950595163,30 +pydtmc,dense-n0010-s02718,dense,10,2718,return/mean-recurrence,0.000334625001414679,3.0145994969643652e-05,0.00031020875758258626,0.0003707604992086999,0.00031687501177657396,0.0003608330061979359,30 +pydtmc,dense-n0010-s02718,dense,10,2718,simulation/10000,0.08233791650127387,0.0016972080047708005,0.08046772949455772,0.08288386500134948,0.08076812500075903,0.08276966700213961,30 +pydtmc,dense-n0010-s02718,dense,10,2718,simulation/100000,0.8119131880084751,0.012449999994714744,0.7934817392415425,0.823983677502838,0.8048422494975966,0.8232164375003777,30 +pydtmc,dense-n0010-s02718,dense,10,2718,stationary,0.00010183350241277367,8.625000191386789e-06,9.435449828743003e-05,0.00011213474863325246,9.49374953052029e-05,0.00011087499296991155,30 +pydtmc,dense-n0010-s02718,dense,10,2718,structure/classes-cold,3.581250348361209e-05,1.7500060494057834e-06,3.425999966566451e-05,3.773950811591931e-05,3.485399793135002e-05,3.658349305624142e-05,30 +pydtmc,dense-n0010-s02718,dense,10,2718,structure/classes-lifecycle,0.0004586870054481551,4.437984898686409e-06,0.00045420799870043993,0.00046293724517454393,0.00045487500028684735,0.00046156250027706847,30 +pydtmc,dense-n0010-s02718,dense,10,2718,structure/classes-warm/access,2.262125002744142e-07,1.91875078598969e-09,2.2445627473643982e-07,2.2890207583259326e-07,2.2497500031022355e-07,2.2758539926144294e-07,30 +pydtmc,dense-n0010-s02718,dense,10,2718,structure/classes-warm/consumed,9.946875004970935e-07,2.997910050908112e-08,9.676812500401867e-07,1.0343978752644033e-06,9.748833494086284e-07,1.0280664787751445e-06,30 +pydtmc,dense-n0010-s02718,dense,10,2718,structure/irreducible-cold,3.550049586920068e-05,2.104497980326414e-06,3.4000244340859354e-05,3.901000309269875e-05,3.429100615903735e-05,3.658300556708127e-05,30 +pydtmc,dense-n0010-s02718,dense,10,2718,structure/irreducible-warm,2.3672500101383777e-07,4.714600072475148e-09,2.3307295014092234e-07,2.461666248564143e-07,2.3393120063701646e-07,2.43564599804813e-07,30 +pydtmc,dense-n0010-s02718,dense,10,2718,visits/bounded-expectation/k-10,2.4478998966515064e-05,2.125001628883183e-06,2.2562002413906157e-05,2.8114507585996762e-05,2.28749995585531e-05,2.6374997105449438e-05,30 +pydtmc,dense-n0010-s02718,dense,10,2718,visits/bounded-expectation/k-100,7.866699888836592e-05,6.035043043084443e-07,7.790599920554087e-05,7.923950397525914e-05,7.829150108591422e-05,7.914549496490508e-05,30 +pydtmc,dense-n0010-s31415,dense,10,31415,construction/public-consumed,0.00040485450153937563,1.897849142551422e-05,0.0003893022549164016,0.0004513225030677859,0.00039127100171754137,0.0004241659917170182,30 +pydtmc,dense-n0010-s31415,dense,10,31415,evolution/k-10,5.293749563861638e-05,1.4169927453622222e-06,5.157225677976385e-05,5.4645748605253175e-05,5.1895993237849325e-05,5.399999663495691e-05,30 +pydtmc,dense-n0010-s31415,dense,10,31415,evolution/k-100,0.0002770414939732291,1.3812488759867847e-05,0.0002672397458809428,0.00029811475178576075,0.00026829150010598823,0.0002936664968729019,30 +pydtmc,dense-n0010-s31415,dense,10,31415,evolution/one-step,3.116649895673618e-05,1.5205077943392098e-06,2.9895745683461428e-05,3.363549694768153e-05,2.997900446644053e-05,3.2208001357503235e-05,30 +pydtmc,dense-n0010-s31415,dense,10,31415,finite-time/n-step/k-10,5.106299795443192e-05,1.8965001800097525e-06,4.919824641547166e-05,5.294824586599134e-05,4.9458001740276814e-05,5.189600051380694e-05,30 +pydtmc,dense-n0010-s31415,dense,10,31415,finite-time/n-step/k-100,0.00027118749858345836,5.146001058164984e-06,0.0002681557452888228,0.00029807324608555064,0.000269124997430481,0.0002927289897343144,30 +pydtmc,dense-n0010-s31415,dense,10,31415,finite-time/observation/k-10,5.193749530008063e-05,1.8124992493540049e-06,5.008349762647413e-05,5.3645253501599655e-05,5.0271497457288206e-05,5.3333002142608166e-05,30 +pydtmc,dense-n0010-s31415,dense,10,31415,finite-time/observation/k-100,0.0002637290017446503,4.812005499843508e-06,0.0002594902543933131,0.0002693544956855476,0.00026000000070780516,0.00026789599360199645,30 +pydtmc,dense-n0010-s31415,dense,10,31415,finite-time/step,1.0209987522102892e-06,1.450025592930615e-07,9.272516763303429e-07,1.2087402865290642e-06,9.584982763044536e-07,1.186999725177884e-06,30 +pydtmc,dense-n0010-s31415,dense,10,31415,hitting-probability/cold-all-states,4.8228990635834634e-05,4.4374901335686445e-06,4.5645254431292415e-05,5.6906250392785296e-05,4.6541499614249915e-05,5.272900307318196e-05,30 +pydtmc,dense-n0010-s31415,dense,10,31415,hitting-time/cold-all-states,0.00010247899626847357,8.166498446371406e-06,9.538525046082214e-05,0.00011435399574111216,9.704200056148693e-05,0.00010806300269905478,30 +pydtmc,dense-n0010-s31415,dense,10,31415,hitting/bounded/at-most/k-10,4.7813002311158925e-05,4.938498022966087e-06,4.4082742533646524e-05,6.10624992987141e-05,4.4937492930330336e-05,5.8604498917702585e-05,30 +pydtmc,dense-n0010-s31415,dense,10,31415,hitting/bounded/at-most/k-100,0.0003373334984644316,2.458997187204659e-06,0.00033514525057398714,0.00034051000693580136,0.00033585400524316356,0.00033883401192724705,30 +pydtmc,dense-n0010-s31415,dense,10,31415,hitting/bounded/exact/k-10,4.2062500142492354e-05,1.2499949662014842e-06,4.1292005334980786e-05,4.382275074021891e-05,4.160450043855235e-05,4.318749415688217e-05,30 +pydtmc,dense-n0010-s31415,dense,10,31415,hitting/bounded/exact/k-100,0.0003341455085319467,5.250003596302122e-06,0.00033086449911934324,0.00034288550523342565,0.000332353993144352,0.0003392080034245737,30 +pydtmc,dense-n0010-s31415,dense,10,31415,hitting/bounded/greater-than/k-10,4.612500197254121e-05,1.541498932056129e-06,4.498925045481883e-05,4.946824265061878e-05,4.527150304056704e-05,4.762499884236604e-05,30 +pydtmc,dense-n0010-s31415,dense,10,31415,hitting/bounded/greater-than/k-100,0.0003388125041965395,5.395995685830712e-06,0.0003347812526044436,0.0003479369952401612,0.00033516700204927474,0.0003456459962762892,30 +pydtmc,dense-n0010-s31415,dense,10,31415,power/10,0.0003268330037826672,9.145500371232629e-06,0.00032031250157160684,0.00034160450741183013,0.000322062500345055,0.0003357751353178173,30 +pydtmc,dense-n0010-s31415,dense,10,31415,power/100,0.0003314790010335855,8.333503501489758e-06,0.00032382325298385695,0.0003433857527852524,0.0003261875026510097,0.0003375000014784746,30 +pydtmc,dense-n0010-s31415,dense,10,31415,power/2,0.0003264170009060763,5.271504051052034e-06,0.00032133299464476295,0.0003323639975860715,0.0003225625041523017,0.0003292090041213669,30 +pydtmc,dense-n0010-s31415,dense,10,31415,race/forward-committor,0.0002737499962677248,8.228998922277242e-06,0.00026807250469573773,0.0002932502575276885,0.0002694159993552603,0.00028491650300566107,30 +pydtmc,dense-n0010-s31415,dense,10,31415,return/bounded/k-10,4.764600453199819e-05,4.249995981808752e-06,4.4457749027060345e-05,5.871850225958042e-05,4.497899499256164e-05,5.793749733129516e-05,30 +pydtmc,dense-n0010-s31415,dense,10,31415,return/bounded/k-100,0.00033512499794596806,5.938003596384078e-06,0.0003301774959254544,0.00034189600046374835,0.0003329374801978702,0.0003406039977562614,30 +pydtmc,dense-n0010-s31415,dense,10,31415,return/mean-recurrence,0.00029293749685166404,5.062502168584615e-06,0.0002889787429012358,0.0003184272463840898,0.00028972688560315876,0.00030722899828106165,30 +pydtmc,dense-n0010-s31415,dense,10,31415,simulation/10000,0.07776841650047572,0.0004796665016328916,0.07726491699577309,0.0780296247539809,0.07734499999787658,0.07797581249906216,30 +pydtmc,dense-n0010-s31415,dense,10,31415,simulation/100000,0.77273977099685,0.0025076880046981387,0.7706624580023345,0.778673364489805,0.771315729500202,0.7748374584989506,30 +pydtmc,dense-n0010-s31415,dense,10,31415,stationary,9.050000517163426e-05,1.6045087249949574e-06,8.926099326345138e-05,9.387500176671892e-05,8.960400009527802e-05,9.295850759372115e-05,30 +pydtmc,dense-n0010-s31415,dense,10,31415,structure/classes-cold,3.585449303500354e-05,2.2294989321380854e-06,3.383374496479519e-05,3.832274524029344e-05,3.429099160712212e-05,3.737500810530037e-05,30 +pydtmc,dense-n0010-s31415,dense,10,31415,structure/classes-lifecycle,0.00045956249959999695,1.579149829922244e-05,0.0004473749977478292,0.0004947082525177393,0.0004502084993873723,0.0004731664957944304,30 +pydtmc,dense-n0010-s31415,dense,10,31415,structure/classes-warm/access,2.2783330059610307e-07,9.85620063147507e-09,2.2054792498238382e-07,2.442656510538654e-07,2.2111875005066393e-07,2.4239790000137876e-07,30 +pydtmc,dense-n0010-s31415,dense,10,31415,structure/classes-warm/consumed,9.70843749382766e-07,1.638124958844858e-08,9.511136009678011e-07,9.806145993934478e-07,9.543708503770176e-07,9.77320849779062e-07,30 +pydtmc,dense-n0010-s31415,dense,10,31415,structure/irreducible-cold,3.4041499020531774e-05,1.5205005183815956e-06,3.298974843346514e-05,3.7000252632424235e-05,3.327050217194483e-05,3.592012017179512e-05,30 +pydtmc,dense-n0010-s31415,dense,10,31415,structure/irreducible-warm,2.3039169973344541e-07,4.8146001063287195e-09,2.2554479983227794e-07,2.3477707472920885e-07,2.2739164996892213e-07,2.344124499359168e-07,30 +pydtmc,dense-n0010-s31415,dense,10,31415,visits/bounded-expectation/k-10,2.1540996385738254e-05,1.9569997675716877e-06,2.028124436037615e-05,2.6958499802276492e-05,2.079149999190122e-05,2.604200562927872e-05,30 +pydtmc,dense-n0010-s31415,dense,10,31415,visits/bounded-expectation/k-100,7.866700616432354e-05,5.830006557516754e-07,7.795850615366362e-05,7.891674977145158e-05,7.812550029484555e-05,7.885450031608343e-05,30 +pydtmc,dense-n0025-s01729,dense,25,1729,construction/public-consumed,0.0011606875050347298,4.0999497286975384e-05,0.001112604746595025,0.0011833337521238718,0.0011249170056544244,0.0011783750014728867,30 +pydtmc,dense-n0025-s01729,dense,25,1729,evolution/k-10,7.645800360478461e-05,5.187008355278522e-06,7.161474059103057e-05,8.173925016308203e-05,7.377050478680758e-05,8.031250035855919e-05,30 +pydtmc,dense-n0025-s01729,dense,25,1729,evolution/k-100,0.0003097500011790544,1.6145997506100684e-05,0.0002930315022240393,0.0003204065105819609,0.0002938539983006194,0.0003169169940520078,30 +pydtmc,dense-n0025-s01729,dense,25,1729,evolution/one-step,5.127050098963082e-05,4.374502168502659e-06,4.871924829785712e-05,5.72079916310031e-05,4.916700709145516e-05,5.604099715128541e-05,30 +pydtmc,dense-n0025-s01729,dense,25,1729,finite-time/n-step/k-10,7.981250382727012e-05,5.27149677509442e-06,7.5479008955881e-05,8.548999539925717e-05,7.735399412922561e-05,8.341699867742136e-05,30 +pydtmc,dense-n0025-s01729,dense,25,1729,finite-time/n-step/k-100,0.0003011245062225498,1.3644996215589345e-05,0.0002903437562054023,0.00032469800498802215,0.00029424633357848505,0.0003218119964003563,30 +pydtmc,dense-n0025-s01729,dense,25,1729,finite-time/observation/k-10,7.904149970272556e-05,8.291499398183078e-06,7.307274063350633e-05,9.456200132262893e-05,7.339550938922912e-05,9.133400453720242e-05,30 +pydtmc,dense-n0025-s01729,dense,25,1729,finite-time/observation/k-100,0.0003129999968223274,1.0249998013023287e-05,0.000304062992654508,0.00032617699980619363,0.0003060209928662516,0.000320416504109744,30 +pydtmc,dense-n0025-s01729,dense,25,1729,finite-time/step,2.354005118831992e-06,6.040063453838229e-07,1.718490238999948e-06,2.8437571018002927e-06,1.770495146047324e-06,2.708504325710237e-06,30 +pydtmc,dense-n0025-s01729,dense,25,1729,hitting-probability/cold-all-states,9.445849718758836e-05,9.604496881365776e-06,8.737550160731189e-05,0.00010740600919234566,9.004200546769425e-05,0.0001046250035869889,30 +pydtmc,dense-n0025-s01729,dense,25,1729,hitting-time/cold-all-states,0.00017564600420882925,1.875000452855602e-05,0.00016061525457189418,0.0002033852506428957,0.00016770850197644904,0.00019899999460903928,30 +pydtmc,dense-n0025-s01729,dense,25,1729,hitting/bounded/at-most/k-10,6.762499833712354e-05,6.165995728224516e-06,6.289574230322614e-05,7.564574843854643e-05,6.649477745668264e-05,7.154199556680396e-05,30 +pydtmc,dense-n0025-s01729,dense,25,1729,hitting/bounded/at-most/k-100,0.0006107500084908679,3.543750790413469e-05,0.000572832996112993,0.0006329892457870301,0.0005763959998148493,0.0006209580024005845,30 +pydtmc,dense-n0025-s01729,dense,25,1729,hitting/bounded/exact/k-10,6.864600436529145e-05,3.666507836896926e-06,6.605224189115688e-05,7.335375266848132e-05,6.664599641226232e-05,7.227099558804184e-05,30 +pydtmc,dense-n0025-s01729,dense,25,1729,hitting/bounded/exact/k-100,0.0005614994952338748,1.9729501218535006e-05,0.000545468254131265,0.0005900524884054903,0.0005503545035026036,0.0005812089948449284,30 +pydtmc,dense-n0025-s01729,dense,25,1729,hitting/bounded/greater-than/k-10,7.491700671380386e-05,7.708003977313638e-06,6.778099486837164e-05,8.82499989529606e-05,7.029150583548471e-05,8.162499580066651e-05,30 +pydtmc,dense-n0025-s01729,dense,25,1729,hitting/bounded/greater-than/k-100,0.0005899999960092828,1.945850090123713e-05,0.0005737292485719081,0.0006223019918252248,0.000576145997911226,0.0006113954950706102,30 +pydtmc,dense-n0025-s01729,dense,25,1729,power/10,0.0006466665072366595,2.266649971716106e-05,0.0006281664936977904,0.000671864501782693,0.0006307920120889321,0.0006597705068998039,30 +pydtmc,dense-n0025-s01729,dense,25,1729,power/100,0.0006537709996337071,2.5979003112297505e-05,0.0006345837573462632,0.0006877399973745923,0.0006369994953274727,0.0006706859203404744,30 +pydtmc,dense-n0025-s01729,dense,25,1729,power/2,0.0006580209956155159,3.862500307150185e-05,0.000617572743067285,0.0006948125010239892,0.000622500003373716,0.0006882289962959476,30 +pydtmc,dense-n0025-s01729,dense,25,1729,race/forward-committor,0.0009595000010449439,4.347899812273681e-05,0.0009301980098825879,0.001066250497387955,0.0009363330027554184,0.001043917000060901,30 +pydtmc,dense-n0025-s01729,dense,25,1729,return/bounded/k-10,7.231299969134852e-05,5.792498996015638e-06,6.68855027470272e-05,8.568749399273656e-05,6.806249439250678e-05,7.787501090206206e-05,30 +pydtmc,dense-n0025-s01729,dense,25,1729,return/bounded/k-100,0.0005550624991883524,2.1958498109597713e-05,0.0005333337503543589,0.0005777297483291477,0.0005391454978962429,0.0005691459955414757,30 +pydtmc,dense-n0025-s01729,dense,25,1729,return/mean-recurrence,0.001077166998584289,4.458399780560285e-05,0.0010349999938625842,0.0011513327481225133,0.0010393545016995631,0.0011196669947821647,30 +pydtmc,dense-n0025-s01729,dense,25,1729,simulation/10000,0.08843404200160876,0.001175207995402161,0.08737407249645912,0.08959113575110678,0.087944853999943,0.08922800000436837,30 +pydtmc,dense-n0025-s01729,dense,25,1729,simulation/100000,0.8886544584966032,0.015343770493927877,0.8796438227473118,0.9208679272451263,0.8827577920019394,0.9023049165043631,30 +pydtmc,dense-n0025-s01729,dense,25,1729,stationary,0.0003048544967896305,1.8208498659078032e-05,0.00028851025126641616,0.00032809425101731904,0.00029425904067466037,0.00032020800426835194,30 +pydtmc,dense-n0025-s01729,dense,25,1729,structure/classes-cold,0.00014445849956246093,9.16700082598254e-06,0.00013796825805911794,0.00015629174959030934,0.0001402295019943267,0.00015468749188585207,30 +pydtmc,dense-n0025-s01729,dense,25,1729,structure/classes-lifecycle,0.001379353998345323,5.3499999921768904e-05,0.0013082397490506992,0.0014111142481851857,0.0013306664986885153,0.00140097950497875,30 +pydtmc,dense-n0025-s01729,dense,25,1729,structure/classes-warm/access,2.3813120060367508e-07,9.854150266619375e-09,2.310541498445673e-07,2.512332754122326e-07,2.321813008165918e-07,2.4441249915980734e-07,30 +pydtmc,dense-n0025-s01729,dense,25,1729,structure/classes-warm/consumed,1.8421624998154585e-06,1.6212449554586776e-08,1.822027125308523e-06,1.8542499747127295e-06,1.8296375012141653e-06,1.851752099901205e-06,30 +pydtmc,dense-n0025-s01729,dense,25,1729,structure/irreducible-cold,0.00014595849643228576,9.021001460496336e-06,0.00013716625471715815,0.0001537810021545738,0.00014222900063032284,0.00014962499699322507,30 +pydtmc,dense-n0025-s01729,dense,25,1729,structure/irreducible-warm,2.5423540064366533e-07,2.1193701104493808e-08,2.3303959933400622e-07,2.734625002631219e-07,2.3425834951922297e-07,2.648728994245175e-07,30 +pydtmc,dense-n0025-s01729,dense,25,1729,visits/bounded-expectation/k-10,4.224949952913448e-05,3.3544929465278983e-06,3.917749927495606e-05,4.6145989472279325e-05,4.020849883090705e-05,4.495899338508025e-05,30 +pydtmc,dense-n0025-s01729,dense,25,1729,visits/bounded-expectation/k-100,0.00010668750473996624,6.145506631582975e-06,0.00010134349940926768,0.00011345849998178892,0.00010316699626855552,0.00011045850260416046,30 +pydtmc,dense-n0025-s02718,dense,25,2718,construction/public-consumed,0.0013234164944151416,6.14374948781915e-05,0.0012718642465188168,0.001410281747666886,0.00128320849762531,0.0013846250003552996,30 +pydtmc,dense-n0025-s02718,dense,25,2718,evolution/k-10,8.212500688387081e-05,8.08350887382403e-06,7.540624574176036e-05,9.300999954575673e-05,7.712500519119203e-05,8.993699884740636e-05,30 +pydtmc,dense-n0025-s02718,dense,25,2718,evolution/k-100,0.00037460450403159484,5.5834003433119506e-05,0.00032442700103274547,0.0005085625016363338,0.0003654169922810979,0.00047362500481540337,30 +pydtmc,dense-n0025-s02718,dense,25,2718,evolution/one-step,5.504200089490041e-05,3.979497705586255e-06,5.157299528946169e-05,6.0603750171139836e-05,5.1999493734911084e-05,5.881249671801925e-05,30 +pydtmc,dense-n0025-s02718,dense,25,2718,finite-time/n-step/k-10,8.281249756691977e-05,4.2504980228841305e-06,7.934375389595516e-05,8.813549357000738e-05,8.0083504144568e-05,8.645799971418455e-05,30 +pydtmc,dense-n0025-s02718,dense,25,2718,finite-time/n-step/k-100,0.00036839600215898827,1.9250008335802704e-05,0.0003485939960228279,0.00038254174432950094,0.00035316022040206003,0.0003762500055017881,30 +pydtmc,dense-n0025-s02718,dense,25,2718,finite-time/observation/k-10,8.166699990397319e-05,5.521003913599998e-06,7.616674702148885e-05,8.685450302436948e-05,7.670850027352571e-05,8.481461591145487e-05,30 +pydtmc,dense-n0025-s02718,dense,25,2718,finite-time/observation/k-100,0.00036149950028629974,2.795799809973687e-05,0.00035051049417234026,0.00041348925151396543,0.00035268750798422843,0.00040483300836058334,30 +pydtmc,dense-n0025-s02718,dense,25,2718,finite-time/step,2.937500539701432e-06,8.125061867758632e-07,2.1662453946191818e-06,3.833501978078857e-06,2.2915046429261565e-06,3.583001671358943e-06,30 +pydtmc,dense-n0025-s02718,dense,25,2718,hitting-probability/cold-all-states,9.97085080598481e-05,1.5062512829899788e-05,8.687500667292625e-05,0.00012216700270073488,8.900000102585182e-05,0.00011505396905704396,30 +pydtmc,dense-n0025-s02718,dense,25,2718,hitting-time/cold-all-states,0.00018804150022333488,9.041505109053105e-06,0.00018016624744632281,0.00021039599596406333,0.00018235449533676729,0.00020214549294905737,30 +pydtmc,dense-n0025-s02718,dense,25,2718,hitting/bounded/at-most/k-10,8.216700371121988e-05,7.833499694243073e-06,7.45627585274633e-05,9.137524830293842e-05,7.517344238294754e-05,8.860449452186003e-05,30 +pydtmc,dense-n0025-s02718,dense,25,2718,hitting/bounded/at-most/k-100,0.0005378334972192533,2.860400127246976e-05,0.0005033859997638501,0.0005650630046147853,0.0005176664999453351,0.000554896003450267,30 +pydtmc,dense-n0025-s02718,dense,25,2718,hitting/bounded/exact/k-10,8.639550651423633e-05,1.1104501027148217e-05,7.596849900437519e-05,9.752125333761796e-05,7.818749872967601e-05,9.318750380771235e-05,30 +pydtmc,dense-n0025-s02718,dense,25,2718,hitting/bounded/exact/k-100,0.000680895995174069,0.00013439599570119753,0.0005484065040946007,0.0008346047434315551,0.0005545829917537048,0.0007794795019435696,30 +pydtmc,dense-n0025-s02718,dense,25,2718,hitting/bounded/greater-than/k-10,7.522850501118228e-05,2.97899532597512e-06,7.29790044715628e-05,7.984374678926542e-05,7.322900637518615e-05,7.820800237823278e-05,30 +pydtmc,dense-n0025-s02718,dense,25,2718,hitting/bounded/greater-than/k-100,0.000590125004237052,1.7792008293326944e-05,0.0005739164989790879,0.0006188745028339326,0.0005823940879054135,0.0005991361284031879,30 +pydtmc,dense-n0025-s02718,dense,25,2718,power/10,0.0007680209964746609,2.304100780747831e-05,0.0007484169946110342,0.0007913015069789253,0.0007564379993709736,0.0007817495061317459,30 +pydtmc,dense-n0025-s02718,dense,25,2718,power/100,0.0007277295080712065,3.2979492971207947e-05,0.0007028644977253862,0.0007663744981982745,0.0007067709957482293,0.0007562915052403696,30 +pydtmc,dense-n0025-s02718,dense,25,2718,power/2,0.0007496670004911721,4.522899689618498e-05,0.0007121142516552936,0.0007947392514324747,0.0007334585025091656,0.0007702919974690303,30 +pydtmc,dense-n0025-s02718,dense,25,2718,race/forward-committor,0.0010998960060533136,4.5749991841148585e-05,0.0010835104985744692,0.001207646248076344,0.001087625503714662,0.001179978993604891,30 +pydtmc,dense-n0025-s02718,dense,25,2718,return/bounded/k-10,8.833350148051977e-05,1.5020494174677879e-05,7.238549369503744e-05,9.838500409387052e-05,8.008300210349262e-05,9.297899669036269e-05,30 +pydtmc,dense-n0025-s02718,dense,25,2718,return/bounded/k-100,0.0005652289983117953,2.8166490665171295e-05,0.0005487702546815854,0.0006064372464607004,0.0005552085058297962,0.000585916503041517,30 +pydtmc,dense-n0025-s02718,dense,25,2718,return/mean-recurrence,0.0012385625013848767,4.610450559994206e-05,0.001217187240399653,0.0013253960023575928,0.001224728999659419,0.0012859380003646947,30 +pydtmc,dense-n0025-s02718,dense,25,2718,simulation/10000,0.09768677051033592,0.0050044790041283704,0.0937125837590429,0.10347140676094568,0.09504133349400945,0.10278243750508409,30 +pydtmc,dense-n0025-s02718,dense,25,2718,simulation/100000,0.9046438540026429,0.05716214599669911,0.8534120417534723,0.9916914690038539,0.8656060209978023,0.9385589164958219,30 +pydtmc,dense-n0025-s02718,dense,25,2718,stationary,0.0003849165004794486,1.8395992810837924e-05,0.00036730200008605607,0.0004105100088054314,0.0003701879977597855,0.0003953124978579581,30 +pydtmc,dense-n0025-s02718,dense,25,2718,structure/classes-cold,0.0001461455030948855,9.062496246770024e-06,0.00014017725334269926,0.00016089524069684558,0.00014062499394640326,0.00015520799934165552,30 +pydtmc,dense-n0025-s02718,dense,25,2718,structure/classes-lifecycle,0.0015609584952471778,4.02289952035062e-05,0.0015136045003600884,0.0015952497415128164,0.0015258540079230443,0.001584666497365106,30 +pydtmc,dense-n0025-s02718,dense,25,2718,structure/classes-warm/access,2.523000002838671e-07,7.458349136868489e-09,2.485103996150428e-07,2.629979240737157e-07,2.489437501935754e-07,2.62939549429575e-07,30 +pydtmc,dense-n0025-s02718,dense,25,2718,structure/classes-warm/consumed,2.4480500003846828e-06,9.61187506618445e-08,1.9832698249956592e-06,2.5090978997468484e-06,2.166131891262921e-06,2.5014124999870543e-06,30 +pydtmc,dense-n0025-s02718,dense,25,2718,structure/irreducible-cold,0.00018643750081537291,1.3686993042938411e-05,0.00017035425116773695,0.00019753149172174744,0.0001745215049595572,0.0001946875054272823,30 +pydtmc,dense-n0025-s02718,dense,25,2718,structure/irreducible-warm,2.954063005745411e-07,6.468699575634641e-09,2.797292254399508e-07,3.008468251209706e-07,2.857083498383872e-07,2.998103998834268e-07,30 +pydtmc,dense-n0025-s02718,dense,25,2718,visits/bounded-expectation/k-10,3.550000110408291e-05,3.7919890019111335e-06,3.344800279592164e-05,4.643700594897382e-05,3.375050437171012e-05,4.2917003156617284e-05,30 +pydtmc,dense-n0025-s02718,dense,25,2718,visits/bounded-expectation/k-100,0.00011012500181095675,3.082997864112258e-06,0.00010712500079534948,0.00011347924373694696,0.00010747849592007697,0.00011220850137760863,30 +pydtmc,dense-n0025-s31415,dense,25,31415,construction/public-consumed,0.0014316875021904707,6.543748895637691e-05,0.0013422912488749716,0.0014852704953227658,0.001404687500325963,0.001466937996156048,30 +pydtmc,dense-n0025-s31415,dense,25,31415,evolution/k-10,0.00010449999535921961,1.4541496057063341e-05,8.991674985736609e-05,0.00011779200212913565,9.219390722137177e-05,0.00011154200183227658,30 +pydtmc,dense-n0025-s31415,dense,25,31415,evolution/k-100,0.000400041499233339,1.499950303696096e-05,0.00038840649722260423,0.00042220849718432873,0.0003965366360716871,0.00041320799937238917,30 +pydtmc,dense-n0025-s31415,dense,25,31415,evolution/one-step,7.349999941652641e-05,1.2416501704137772e-05,6.133374699857086e-05,8.589575008954853e-05,6.468750507337973e-05,8.208299550460652e-05,30 +pydtmc,dense-n0025-s31415,dense,25,31415,finite-time/n-step/k-10,0.00010145849955733865,6.979498721193522e-06,9.459374632569961e-05,0.00010802050383063033,9.574999421602115e-05,0.00010445799853187054,30 +pydtmc,dense-n0025-s31415,dense,25,31415,finite-time/n-step/k-100,0.0003810835041804239,9.583513019606471e-06,0.0003745102512766607,0.00040882249595597386,0.00037522850470850244,0.0003909584993380122,30 +pydtmc,dense-n0025-s31415,dense,25,31415,finite-time/observation/k-10,0.0001006874954327941,9.999996109399945e-06,9.11247479962185e-05,0.00011136475586681627,9.354100620839745e-05,0.00011010449816239998,30 +pydtmc,dense-n0025-s31415,dense,25,31415,finite-time/observation/k-100,0.0003774579963646829,1.468750269850716e-05,0.0003709997545229271,0.00039654125430388376,0.0003723125046235509,0.0003911460007657297,30 +pydtmc,dense-n0025-s31415,dense,25,31415,finite-time/step,3.3960022847168148e-06,9.380019037052989e-07,2.6249945221934468e-06,4.540997906588018e-06,2.7295027393847704e-06,4.334004188422114e-06,30 +pydtmc,dense-n0025-s31415,dense,25,31415,hitting-probability/cold-all-states,0.00010254199878545478,1.2896001862827688e-05,9.754174607223831e-05,0.00012181248894194141,9.954199776984751e-05,0.00011575000098673627,30 +pydtmc,dense-n0025-s31415,dense,25,31415,hitting-time/cold-all-states,0.00021972949616611004,3.579199255909771e-05,0.00019210350365028717,0.0003295840033388231,0.0001996040009544231,0.0003005834951181896,30 +pydtmc,dense-n0025-s31415,dense,25,31415,hitting/bounded/at-most/k-10,8.956200326792896e-05,7.229500624816865e-06,8.369824354304001e-05,0.00010265675518894568,8.479200187139213e-05,9.672949818195775e-05,30 +pydtmc,dense-n0025-s31415,dense,25,31415,hitting/bounded/at-most/k-100,0.0006910625015734695,3.4708500606939197e-05,0.0005869585038453806,0.0007054579946270678,0.0006491460007964633,0.0007021670026006177,30 +pydtmc,dense-n0025-s31415,dense,25,31415,hitting/bounded/exact/k-10,8.987499313661829e-05,1.0187497537117451e-05,8.047950905165635e-05,9.993775529437698e-05,8.272900595329702e-05,9.654198947828263e-05,30 +pydtmc,dense-n0025-s31415,dense,25,31415,hitting/bounded/exact/k-100,0.0006611879944102839,1.8458500562701374e-05,0.0006436977491830476,0.0006783959979657084,0.0006580625049537048,0.0006675420008832589,30 +pydtmc,dense-n0025-s31415,dense,25,31415,hitting/bounded/greater-than/k-10,9.058299474418163e-05,6.333000783342868e-06,8.522924326825887e-05,9.749950550030917e-05,8.656250429339707e-05,9.560400212649256e-05,30 +pydtmc,dense-n0025-s31415,dense,25,31415,hitting/bounded/greater-than/k-100,0.0006562710041180253,3.3354503102600574e-05,0.0006267292483244091,0.0006990625006437767,0.0006323124980553985,0.0006884795002406463,30 +pydtmc,dense-n0025-s31415,dense,25,31415,power/10,0.0007717084954492748,4.2687999666668475e-05,0.0007271972426678985,0.0008008332479221281,0.0007511660078307614,0.000788541990914382,30 +pydtmc,dense-n0025-s31415,dense,25,31415,power/100,0.0008120624988805503,6.177100294735283e-05,0.0007444057446264196,0.000861886001075618,0.0007530000002589077,0.0008522709977114573,30 +pydtmc,dense-n0025-s31415,dense,25,31415,power/2,0.0007802085019648075,4.0936989535111934e-05,0.0007345522535615601,0.0008062192428042181,0.0007543125102529302,0.0008011460013221949,30 +pydtmc,dense-n0025-s31415,dense,25,31415,race/forward-committor,0.001057208501151763,4.9436996050644666e-05,0.0009713125000416767,0.00108066649409011,0.0009955209970939904,0.0010707705005188473,30 +pydtmc,dense-n0025-s31415,dense,25,31415,return/bounded/k-10,9.737499931361526e-05,8.10450001154095e-06,9.105250501306728e-05,0.00010697900506784208,9.195800521411002e-05,0.00010468749678693712,30 +pydtmc,dense-n0025-s31415,dense,25,31415,return/bounded/k-100,0.000697520503308624,5.2437506383284926e-05,0.0006624272427870892,0.0007753547506581526,0.0006693960021948442,0.0007527495035901666,30 +pydtmc,dense-n0025-s31415,dense,25,31415,return/mean-recurrence,0.0014228749932954088,0.00016872900596354157,0.0012291567545617,0.0015116557442524936,0.0012959584928466938,0.0014683124973089434,30 +pydtmc,dense-n0025-s31415,dense,25,31415,simulation/10000,0.10823502049606759,0.005187728995224461,0.10413313574463245,0.11411068799498025,0.10626443800720153,0.11324664599669632,30 +pydtmc,dense-n0025-s31415,dense,25,31415,simulation/100000,1.0680679165016045,0.012009187506919261,1.0568369167522178,1.0815556984962313,1.06089470799634,1.0752434585010633,30 +pydtmc,dense-n0025-s31415,dense,25,31415,stationary,0.0003981869958806783,1.9854502170346677e-05,0.0003808645014942158,0.00041926050471374765,0.0003849789936793968,0.0004173540000920184,30 +pydtmc,dense-n0025-s31415,dense,25,31415,structure/classes-cold,0.0001824375067371875,7.0624955696985126e-06,0.00017781250062398612,0.00019865575450239703,0.00017845850379671901,0.00019458350288914517,30 +pydtmc,dense-n0025-s31415,dense,25,31415,structure/classes-lifecycle,0.0017393744928995147,9.86045051831752e-05,0.0016276982532872353,0.0018251877518196125,0.0016625624994048849,0.00180264549999265,30 +pydtmc,dense-n0025-s31415,dense,25,31415,structure/classes-warm/access,3.146374998323153e-07,1.0264650336466786e-08,2.9530210013035683e-07,3.2370727531088046e-07,3.1019790039863437e-07,3.189999501046259e-07,30 +pydtmc,dense-n0025-s31415,dense,25,31415,structure/classes-warm/consumed,2.4074583503534085e-06,1.0508755003684191e-07,2.3401594244205623e-06,2.554832300666021e-06,2.3526228993432596e-06,2.533333349128952e-06,30 +pydtmc,dense-n0025-s31415,dense,25,31415,structure/irreducible-cold,0.00017966650193557143,1.6624995623715222e-05,0.00016366700219805352,0.0001989267511817161,0.00016722900181775913,0.0001921454895636998,30 +pydtmc,dense-n0025-s31415,dense,25,31415,structure/irreducible-warm,3.061416500713676e-07,5.833349860040454e-09,2.9879062494728716e-07,3.095999745710287e-07,3.012562003277708e-07,3.091395497904159e-07,30 +pydtmc,dense-n0025-s31415,dense,25,31415,visits/bounded-expectation/k-10,4.5583496103063226e-05,4.1249950299970806e-06,4.220824848744087e-05,5.181225424166769e-05,4.316651029512286e-05,5.116649845149368e-05,30 +pydtmc,dense-n0025-s31415,dense,25,31415,visits/bounded-expectation/k-100,0.00014029149315319955,8.10450001154095e-06,0.00013054148803348653,0.00014582274525309913,0.00013297949772095308,0.00014354150334838778,30 +pydtmc,dense-n0050-s01729,dense,50,1729,construction/public-consumed,0.004156416500336491,0.00013872949784854427,0.004045114506880054,0.004295197995816125,0.004055708006490022,0.00428235450090142,30 +pydtmc,dense-n0050-s01729,dense,50,1729,evolution/k-10,0.0001384584975312464,1.5604004147462547e-05,0.0001219374971697107,0.00014497949814540334,0.0001251874928129837,0.00014308400568552315,30 +pydtmc,dense-n0050-s01729,dense,50,1729,evolution/k-100,0.00042554149695206434,2.2853993868920952e-05,0.00040745849764789455,0.0004527812416199595,0.00041566700383555144,0.00044170849287183955,30 +pydtmc,dense-n0050-s01729,dense,50,1729,evolution/one-step,0.00011258299491601065,9.25049971556291e-06,0.00010280175774823874,0.00012117699588998221,0.00010672950156731531,0.00011904149869224057,30 +pydtmc,dense-n0050-s01729,dense,50,1729,finite-time/n-step/k-10,0.00014372949226526543,1.5979487216100097e-05,0.0001288227504119277,0.00015989524763426743,0.0001330834929831326,0.0001547914944239892,30 +pydtmc,dense-n0050-s01729,dense,50,1729,finite-time/n-step/k-100,0.00041283350583398715,2.0208506612107158e-05,0.0003923330041288864,0.0004314895013521891,0.0003946249926229939,0.00042516599933151156,30 +pydtmc,dense-n0050-s01729,dense,50,1729,finite-time/observation/k-10,0.00013604199193650857,1.0520496289245784e-05,0.00012570850230986252,0.00014621849550167099,0.00012762550613842905,0.00014266648940974846,30 +pydtmc,dense-n0050-s01729,dense,50,1729,finite-time/observation/k-100,0.0004336460042395629,4.510401049628854e-05,0.0004010937591374386,0.0004809062556887511,0.00041156299266731367,0.00046512499829987064,30 +pydtmc,dense-n0050-s01729,dense,50,1729,finite-time/step,6.8954977905377746e-06,2.812994353007525e-06,5.177244020160288e-06,9.854240488493815e-06,5.229499947745353e-06,8.583498129155487e-06,30 +pydtmc,dense-n0050-s01729,dense,50,1729,hitting-probability/cold-all-states,0.00027577100263442844,2.0312509150244296e-05,0.00025870850367937237,0.00031386474074679427,0.00026460450317244977,0.00030335449264384806,30 +pydtmc,dense-n0050-s01729,dense,50,1729,hitting-time/cold-all-states,0.0005281874982756563,5.568750202655792e-05,0.0004773125001520384,0.0005910932522965595,0.0004987290012650192,0.0005729585027438588,30 +pydtmc,dense-n0050-s01729,dense,50,1729,hitting/bounded/at-most/k-10,0.00014881250535836443,1.8770995666272938e-05,0.00012560375034809113,0.00016143749962793663,0.0001343335025012493,0.00015597949823131785,30 +pydtmc,dense-n0050-s01729,dense,50,1729,hitting/bounded/at-most/k-100,0.0008758750045672059,4.7313005779869854e-05,0.0008442189937341027,0.000942385242524324,0.0008513129942002706,0.0009186665047309361,30 +pydtmc,dense-n0050-s01729,dense,50,1729,hitting/bounded/exact/k-10,0.00012104200141038746,2.4084001779556274e-05,9.834324373514391e-05,0.00014357351028593257,0.0001079165012924932,0.00013039549958193675,30 +pydtmc,dense-n0050-s01729,dense,50,1729,hitting/bounded/exact/k-100,0.0008528955004294403,3.779150574700907e-05,0.0008251460021710955,0.0009147085002041422,0.0008269170066341758,0.0008952085045166314,30 +pydtmc,dense-n0050-s01729,dense,50,1729,hitting/bounded/greater-than/k-10,0.00012087450159015134,2.202049654442817e-05,0.00010057300460175611,0.00014314524742076173,0.00010525000107008964,0.00013549999857787043,30 +pydtmc,dense-n0050-s01729,dense,50,1729,hitting/bounded/greater-than/k-100,0.0009372499989694916,5.4666990763507783e-05,0.000897009751497535,0.0010658649989636615,0.0009098125083255582,0.0010160356176129421,30 +pydtmc,dense-n0050-s01729,dense,50,1729,power/10,0.0018645210002432577,0.00016570800653425977,0.0016665004877722822,0.0019990102482552174,0.001817728996684309,0.0019535630053724162,30 +pydtmc,dense-n0050-s01729,dense,50,1729,power/100,0.00195789599820273,7.914599700598046e-05,0.001909229493321618,0.0020521669976005796,0.0019235415020375513,0.002008708004723303,30 +pydtmc,dense-n0050-s01729,dense,50,1729,power/2,0.001700312495813705,0.00013852100528310984,0.0016247292442130856,0.0018421357453917153,0.001650375001190696,0.0018388335010968149,30 +pydtmc,dense-n0050-s01729,dense,50,1729,race/forward-committor,0.0032388545005233027,7.818700396455824e-05,0.0031604899959347676,0.0033136975034722127,0.0031705205037724227,0.0032823330038809218,30 +pydtmc,dense-n0050-s01729,dense,50,1729,return/bounded/k-10,0.00013912499707657844,1.714599784463644e-05,0.0001241667523572687,0.00015661474390071817,0.00012779149983543903,0.00014891650789650157,30 +pydtmc,dense-n0050-s01729,dense,50,1729,return/bounded/k-100,0.0009135000000242144,4.212500061839819e-05,0.000883542001247406,0.0010181872457906138,0.0008848959987517446,0.0009826039968174882,30 +pydtmc,dense-n0050-s01729,dense,50,1729,return/mean-recurrence,0.0036273959995014593,0.00022408349468605593,0.0034633540017239284,0.004013052501250058,0.003503449996605923,0.003936708497349173,30 +pydtmc,dense-n0050-s01729,dense,50,1729,simulation/10000,0.12362381249840837,0.005991479505610187,0.11932844825059874,0.1321877919981489,0.12090650000754977,0.12725889550347347,30 +pydtmc,dense-n0050-s01729,dense,50,1729,simulation/100000,0.992740520996449,0.048197125004662666,0.9592550942434173,1.0691540417537908,0.9729465000054915,1.053187124998658,30 +pydtmc,dense-n0050-s01729,dense,50,1729,stationary,0.0010387085058027878,5.656250141328201e-05,0.0009694269974716008,0.0010861459995794576,0.0010046008541394259,0.0010706670000217855,30 +pydtmc,dense-n0050-s01729,dense,50,1729,structure/classes-cold,0.000807166492450051,0.00016581249656155705,0.0006495204943348654,0.0009763122434378602,0.0006848871338661412,0.0009102920012082905,30 +pydtmc,dense-n0050-s01729,dense,50,1729,structure/classes-lifecycle,0.00495591700746445,0.00034658350341487676,0.004634302502381615,0.005362635496567236,0.004655917000491172,0.005237083496467676,30 +pydtmc,dense-n0050-s01729,dense,50,1729,structure/classes-warm/access,3.194187498593237e-07,3.084789932472635e-08,2.911844007030595e-07,3.503812240523985e-07,3.017729504790623e-07,3.489145492494572e-07,30 +pydtmc,dense-n0050-s01729,dense,50,1729,structure/classes-warm/consumed,4.3564083498495165e-06,1.8670830031624048e-07,4.146487550315214e-06,4.534727075588307e-06,4.1950999999244225e-06,4.5082354001351636e-06,30 +pydtmc,dense-n0050-s01729,dense,50,1729,structure/irreducible-cold,0.0005644789998768829,3.422900044824928e-05,0.0005484792418428697,0.000598999500653008,0.0005528129986487329,0.0005922920099692419,30 +pydtmc,dense-n0050-s01729,dense,50,1729,structure/irreducible-warm,2.6428334967931736e-07,3.4728996979538234e-09,2.6102495030499994e-07,2.679103999980725e-07,2.614687502500601e-07,2.6706659991759806e-07,30 +pydtmc,dense-n0050-s01729,dense,50,1729,visits/bounded-expectation/k-10,8.085400622803718e-05,9.16700082598254e-06,7.355200432357378e-05,9.453175516682677e-05,7.608349551446736e-05,8.602099842391908e-05,30 +pydtmc,dense-n0050-s01729,dense,50,1729,visits/bounded-expectation/k-100,0.00017341649800073355,8.854505722410977e-06,0.0001680724999459926,0.00019193800108041614,0.00016889236940187402,0.00018424999143462628,30 +pydtmc,dense-n0050-s02718,dense,50,2718,construction/public-consumed,0.0035875410030712374,0.00014435400225920603,0.003491302006295882,0.0038091770038590766,0.0035236254989285953,0.00372204149607569,30 +pydtmc,dense-n0050-s02718,dense,50,2718,evolution/k-10,0.00010749950160970911,1.691650686552748e-05,8.935399455367588e-05,0.00012184400475234725,9.160349873127416e-05,0.00012022950249956921,30 +pydtmc,dense-n0050-s02718,dense,50,2718,evolution/k-100,0.0003511874965624884,1.1625495972111821e-05,0.00033858274400699884,0.00035944800038123503,0.000340229002176784,0.0003571460038074292,30 +pydtmc,dense-n0050-s02718,dense,50,2718,evolution/one-step,8.079149847617373e-05,1.5082994650583714e-05,6.566675438079983e-05,9.412474537384696e-05,6.693750037811697e-05,8.802100637694821e-05,30 +pydtmc,dense-n0050-s02718,dense,50,2718,finite-time/n-step/k-10,8.754200098337606e-05,1.2915043043904006e-06,8.691674520378001e-05,8.975024684332311e-05,8.706300286576152e-05,8.912499470170587e-05,30 +pydtmc,dense-n0050-s02718,dense,50,2718,finite-time/n-step/k-100,0.00034895849967142567,1.281250297324732e-05,0.0003400725036044605,0.0003653130006568972,0.00034235450584674254,0.0003608960032579489,30 +pydtmc,dense-n0050-s02718,dense,50,2718,finite-time/observation/k-10,0.00013635399955091998,1.8999999156221747e-05,0.00011692674161167815,0.00015342675396823324,0.00012029200297547504,0.0001478749982197769,30 +pydtmc,dense-n0050-s02718,dense,50,2718,finite-time/observation/k-100,0.00036545799230225384,1.906249235616997e-05,0.00035346875301911496,0.000392541493056342,0.00036170849489280954,0.00037922900082776323,30 +pydtmc,dense-n0050-s02718,dense,50,2718,finite-time/step,4.458001058083028e-06,2.583001332823187e-06,2.1139931050129235e-06,7.636004738742486e-06,2.707995008677244e-06,6.417001713998616e-06,30 +pydtmc,dense-n0050-s02718,dense,50,2718,hitting-probability/cold-all-states,0.00024147950171027333,2.170899824704975e-05,0.00022387549688573927,0.00027293775201542303,0.00023456249618902802,0.000265499998931773,30 +pydtmc,dense-n0050-s02718,dense,50,2718,hitting-time/cold-all-states,0.0004338750004535541,2.8604008548427373e-05,0.00041135425271932036,0.0004669062436732929,0.0004212080020806752,0.0004612080010701902,30 +pydtmc,dense-n0050-s02718,dense,50,2718,hitting/bounded/at-most/k-10,0.00012527099897852167,2.5625500711612403e-05,0.00010053074220195413,0.00015003149383119307,0.00011285399523330852,0.00013170799502404407,30 +pydtmc,dense-n0050-s02718,dense,50,2718,hitting/bounded/at-most/k-100,0.0007905414968263358,2.3187501938082278e-05,0.0007702184993831906,0.0008220624949899502,0.0007718120032222942,0.0008060093714448158,30 +pydtmc,dense-n0050-s02718,dense,50,2718,hitting/bounded/exact/k-10,0.00011922900011995807,7.520997314713895e-06,0.00011198924767086282,0.0001267394945898559,0.00011427099525462836,0.00012585399235831574,30 +pydtmc,dense-n0050-s02718,dense,50,2718,hitting/bounded/exact/k-100,0.0008252295010606758,2.9499999072868377e-05,0.0007993124963832088,0.0008553957486583386,0.0008025834977161139,0.0008375414981856011,30 +pydtmc,dense-n0050-s02718,dense,50,2718,hitting/bounded/greater-than/k-10,8.943750435719267e-05,1.5415062080137432e-06,8.827074998407625e-05,0.00011130224447697401,8.849998994264752e-05,0.0001011454951367341,30 +pydtmc,dense-n0050-s02718,dense,50,2718,hitting/bounded/greater-than/k-100,0.0008424164916505106,5.7416495110373944e-05,0.0008057609920797404,0.0009274792428186629,0.0008131250069709495,0.0009001659927889705,30 +pydtmc,dense-n0050-s02718,dense,50,2718,power/10,0.0015406880047521554,9.23329935176298e-05,0.0014876772511343006,0.0016666770025040023,0.0014951670018490404,0.001639458496356383,30 +pydtmc,dense-n0050-s02718,dense,50,2718,power/100,0.0015814375001355074,7.61045012040995e-05,0.0015102809957170393,0.0016695307531335857,0.0015172499988693744,0.0016357295025954954,30 +pydtmc,dense-n0050-s02718,dense,50,2718,power/2,0.001564291502290871,7.654150249436498e-05,0.001493187744927127,0.001654802243137965,0.0015128749946597964,0.001624166005058214,30 +pydtmc,dense-n0050-s02718,dense,50,2718,race/forward-committor,0.003063312506128568,0.00017481249233242124,0.0029836670037184376,0.0032404374978796113,0.0030268124901340343,0.003122750495094806,30 +pydtmc,dense-n0050-s02718,dense,50,2718,return/bounded/k-10,0.0001155205027316697,1.9249004253651947e-05,9.624024824006483e-05,0.00012702124513452873,9.925050107995048e-05,0.00012354200589470565,30 +pydtmc,dense-n0050-s02718,dense,50,2718,return/bounded/k-100,0.0008042919944273308,2.7291498554404825e-05,0.0007866672603995539,0.0008357600090675987,0.0007921664946479723,0.0008340839995071292,30 +pydtmc,dense-n0050-s02718,dense,50,2718,return/mean-recurrence,0.003366896002262365,0.00010960399959003553,0.0032509065058548003,0.0034636669952305965,0.0032979040097416146,0.0034499164976296015,30 +pydtmc,dense-n0050-s02718,dense,50,2718,simulation/10000,0.08775620850065025,0.001726375507132616,0.08641341599650332,0.08963332325583906,0.08706866650754819,0.08866831249906681,30 +pydtmc,dense-n0050-s02718,dense,50,2718,simulation/100000,0.8860580204927828,0.02347916650614934,0.8532635520059557,0.9032308539972291,0.8635094999917783,0.8960148335027043,30 +pydtmc,dense-n0050-s02718,dense,50,2718,stationary,0.0008828330028336495,4.864649963565171e-05,0.0008407502537011169,0.0009321147517766804,0.0008727289969101548,0.0009196250030072406,30 +pydtmc,dense-n0050-s02718,dense,50,2718,structure/classes-cold,0.00047987500147428364,8.729002729523927e-06,0.00047272875963244587,0.0004917602600471582,0.0004742919991258532,0.00048618750588502735,30 +pydtmc,dense-n0050-s02718,dense,50,2718,structure/classes-lifecycle,0.005363333497371059,0.0010272500003338791,0.004369489251985215,0.006319635249383282,0.004636937504983507,0.00562535449716961,30 +pydtmc,dense-n0050-s02718,dense,50,2718,structure/classes-warm/access,2.3092710034688935e-07,5.4542011639569035e-09,2.2607290011364966e-07,2.4215837511292196e-07,2.2703130016452635e-07,2.3515835055150092e-07,30 +pydtmc,dense-n0050-s02718,dense,50,2718,structure/classes-warm/consumed,3.126252099900739e-06,6.149584951344855e-08,3.0657291506940963e-06,3.184381200117059e-06,3.074527031421894e-06,3.1515687507635447e-06,30 +pydtmc,dense-n0050-s02718,dense,50,2718,structure/irreducible-cold,0.000476249995699618,9.083007171284407e-06,0.0004682914986915421,0.00048622899703332223,0.0004718330019386485,0.0004849580000154674,30 +pydtmc,dense-n0050-s02718,dense,50,2718,structure/irreducible-warm,2.31108349544229e-07,5.754150333814323e-09,2.2627502512477803e-07,2.4785730056464677e-07,2.2760624997317792e-07,2.4242084982688535e-07,30 +pydtmc,dense-n0050-s02718,dense,50,2718,visits/bounded-expectation/k-10,6.51459995424375e-05,5.624489858746529e-06,6.168748950585723e-05,7.810425449861214e-05,6.277047104958912e-05,7.054099114611745e-05,30 +pydtmc,dense-n0050-s02718,dense,50,2718,visits/bounded-expectation/k-100,0.00015060450095916167,6.646492693107575e-06,0.0001450417476007715,0.0001634165018913336,0.00014554200606653467,0.00015724950935691595,30 +pydtmc,dense-n0050-s31415,dense,50,31415,construction/public-consumed,0.0037665210038539954,0.00015874950622674078,0.0036263642468838952,0.00415107274602633,0.0036394164999364875,0.004138832999160513,30 +pydtmc,dense-n0050-s31415,dense,50,31415,evolution/k-10,0.00010550000297371298,7.729497156105936e-06,9.804173896554857e-05,0.00011357249968568794,0.00010075001046061516,0.00011158349661855027,30 +pydtmc,dense-n0050-s31415,dense,50,31415,evolution/k-100,0.0003716040009749122,1.2395503290463239e-05,0.00036057248871657066,0.00038526049684151076,0.0003635835091699846,0.0003797289973590523,30 +pydtmc,dense-n0050-s31415,dense,50,31415,evolution/one-step,8.754200098337606e-05,8.333496225532144e-06,8.132274524541572e-05,0.00011291675036773086,8.332570487254998e-05,0.00010568143752607264,30 +pydtmc,dense-n0050-s31415,dense,50,31415,finite-time/n-step/k-10,0.00010339599975850433,9.083996701519936e-06,9.5249753940152e-05,0.000117583495011786,9.729200246511027e-05,0.00010945800750050694,30 +pydtmc,dense-n0050-s31415,dense,50,31415,finite-time/n-step/k-100,0.00036610399547498673,2.8041489713359624e-05,0.0003398127591935918,0.000393833495763829,0.00034929100365843624,0.0003884605768689653,30 +pydtmc,dense-n0050-s31415,dense,50,31415,finite-time/observation/k-10,0.00012122950283810496,1.3980003132019192e-05,0.0001087079945136793,0.00013693750588572584,0.00011175000690855086,0.00012637549662031233,30 +pydtmc,dense-n0050-s31415,dense,50,31415,finite-time/observation/k-100,0.000375979499949608,2.1395499061327428e-05,0.00036232275306247175,0.00040355249802814797,0.00036991650267736986,0.0003973749990109354,30 +pydtmc,dense-n0050-s31415,dense,50,31415,finite-time/step,4.187000740785152e-06,1.4999968698248267e-06,3.6040037230122834e-06,7.020251359790564e-06,3.749999450519681e-06,5.812500603497028e-06,30 +pydtmc,dense-n0050-s31415,dense,50,31415,hitting-probability/cold-all-states,0.0002260624969494529,2.0478502847254276e-05,0.00020234425028320402,0.0002449372550472617,0.000206666998565197,0.00024129100347636268,30 +pydtmc,dense-n0050-s31415,dense,50,31415,hitting-time/cold-all-states,0.0004178540038992651,3.3792006433941424e-05,0.0003978964959969744,0.000491416754812235,0.0004048749979119748,0.0004566670104395598,30 +pydtmc,dense-n0050-s31415,dense,50,31415,hitting/bounded/at-most/k-10,0.00012010399950668216,1.4874996850267053e-05,0.0001057187546393834,0.00013558325008489192,0.00010766649211291224,0.00012993749987799674,30 +pydtmc,dense-n0050-s31415,dense,50,31415,hitting/bounded/at-most/k-100,0.0008708125023986213,2.3125001462176442e-05,0.0008312812497024424,0.0008925000001909211,0.000856229497003369,0.0008857294960762374,30 +pydtmc,dense-n0050-s31415,dense,50,31415,hitting/bounded/exact/k-10,0.00011277050361968577,1.5354002243839204e-05,9.819774641073309e-05,0.0001268225023522973,0.0001036454996210523,0.0001236454991158098,30 +pydtmc,dense-n0050-s31415,dense,50,31415,hitting/bounded/exact/k-100,0.0008359159983228892,3.0333001632243395e-05,0.0008085417466645595,0.0008688749985594768,0.0008239164963015355,0.0008537079993402585,30 +pydtmc,dense-n0050-s31415,dense,50,31415,hitting/bounded/greater-than/k-10,0.0001251875000889413,1.0832998668774962e-05,0.00011693724081851542,0.00013660349941346794,0.00011916649236809462,0.0001323749966104515,30 +pydtmc,dense-n0050-s31415,dense,50,31415,hitting/bounded/greater-than/k-100,0.0008784375022514723,6.310400203801692e-05,0.0008115099954011384,0.0009094477463804651,0.0008174789982149377,0.0008911874974728562,30 +pydtmc,dense-n0050-s31415,dense,50,31415,power/10,0.0016606044955551624,7.606250437675044e-05,0.0016149797520483844,0.0018303230026504025,0.0016297289985232055,0.0017693749978207052,30 +pydtmc,dense-n0050-s31415,dense,50,31415,power/100,0.0015743540061521344,6.912499520694837e-05,0.00152327125397278,0.001659312500123633,0.001542791498650331,0.0016383330075768754,30 +pydtmc,dense-n0050-s31415,dense,50,31415,power/2,0.002008624993322883,0.0002074999938486144,0.0018036352521448862,0.0022135207436804194,0.0018216459939139895,0.002162541502912063,30 +pydtmc,dense-n0050-s31415,dense,50,31415,race/forward-committor,0.003022937002242543,9.66039951890707e-05,0.0029164480001782067,0.0031099269981496036,0.0029443749954225495,0.003071687497140374,30 +pydtmc,dense-n0050-s31415,dense,50,31415,return/bounded/k-10,0.00011693750275298953,8.541996066924185e-06,0.00011029174493160099,0.00013526100156013854,0.00011152099614264444,0.00012462499580578879,30 +pydtmc,dense-n0050-s31415,dense,50,31415,return/bounded/k-100,0.0008807915000943467,2.0500003302004188e-05,0.0008663437474751845,0.0009057912466232665,0.0008731874986551702,0.0008955415032687597,30 +pydtmc,dense-n0050-s31415,dense,50,31415,return/mean-recurrence,0.0031943750000209548,7.472949801012874e-05,0.0031276872541639023,0.0034019170052488334,0.003143375004583504,0.0033026669989340007,30 +pydtmc,dense-n0050-s31415,dense,50,31415,simulation/10000,0.10273808300553355,0.006403583007340785,0.09159995824302314,0.10555203174953931,0.0959514589922037,0.10484845849714475,30 +pydtmc,dense-n0050-s31415,dense,50,31415,simulation/100000,1.0178997500042897,0.026976083492627367,0.9790028755123785,1.0347006767588027,0.9849375414996757,1.0284208955054055,30 +pydtmc,dense-n0050-s31415,dense,50,31415,stationary,0.0008650210002087988,2.6104491553269327e-05,0.000840301756397821,0.0008901667461032048,0.0008454789931420237,0.0008841045055305585,30 +pydtmc,dense-n0050-s31415,dense,50,31415,structure/classes-cold,0.000449645500339102,1.36044982355088e-05,0.0004373537485662382,0.00046572951032430865,0.0004408329987199977,0.00046314599603647366,30 +pydtmc,dense-n0050-s31415,dense,50,31415,structure/classes-lifecycle,0.004135707997193094,0.00012254199828021228,0.004018656247353647,0.004252583741617855,0.004059082988533191,0.004231815646016912,30 +pydtmc,dense-n0050-s31415,dense,50,31415,structure/classes-warm/access,2.2070204940973782e-07,2.3583503207191914e-09,2.1895205100008752e-07,2.2553230010089463e-07,2.1930000002612362e-07,2.2380834998330102e-07,30 +pydtmc,dense-n0050-s31415,dense,50,31415,structure/classes-warm/consumed,3.005864550505066e-06,5.212500400375528e-09,3.0021948001376585e-06,3.015760424386826e-06,3.00398330000462e-06,3.007508299924666e-06,30 +pydtmc,dense-n0050-s31415,dense,50,31415,structure/irreducible-cold,0.00048224999773083255,1.2291995517443866e-05,0.00047077050112420693,0.0004940934995829593,0.00047562499821651727,0.00048595800035400316,30 +pydtmc,dense-n0050-s31415,dense,50,31415,structure/irreducible-warm,2.330041490495205e-07,2.516701351851209e-09,2.3133122449507936e-07,2.3921357424114835e-07,2.3182914956123568e-07,2.3573959988425485e-07,30 +pydtmc,dense-n0050-s31415,dense,50,31415,visits/bounded-expectation/k-10,6.0937505622860044e-05,4.62549360236153e-06,5.744800000684336e-05,6.714624760206789e-05,5.860400415258482e-05,6.587550160475075e-05,30 +pydtmc,dense-n0050-s31415,dense,50,31415,visits/bounded-expectation/k-100,0.00016414649871876463,4.749505023937672e-06,0.0001608225065865554,0.00016937524560489692,0.0001617500020074658,0.0001688960037427023,30 +pydtmc,dense-n0100-s01729,dense,100,1729,construction/public-consumed,0.015764895499160048,0.000982937497610692,0.014900478749041213,0.01721334399553598,0.015056916497997008,0.01645833349903114,30 +pydtmc,dense-n0100-s01729,dense,100,1729,evolution/k-10,0.00023322950437432155,2.2145504772197455e-05,0.0002169582548958715,0.0002723337529459968,0.00022233299387153238,0.0002511455022613518,30 +pydtmc,dense-n0100-s01729,dense,100,1729,evolution/k-100,0.0005075000080978498,4.685450403485447e-05,0.00046371925054700114,0.0005565725041378755,0.00046795850357739255,0.0005379160138545558,30 +pydtmc,dense-n0100-s01729,dense,100,1729,evolution/one-step,0.00020589599444065243,1.9020502804778516e-05,0.00019982250159955584,0.00022546874970430508,0.00020341650815680623,0.00022445799550041556,30 +pydtmc,dense-n0100-s01729,dense,100,1729,finite-time/n-step/k-10,0.0002333329975954257,1.3354496331885457e-05,0.00021766650024801493,0.00024248950285254978,0.00021991650282870978,0.00023872900783317164,30 +pydtmc,dense-n0100-s01729,dense,100,1729,finite-time/n-step/k-100,0.000615770994045306,2.4771004973445088e-05,0.000593864249822218,0.0006413227529264987,0.0006004374954500236,0.0006319585008895956,30 +pydtmc,dense-n0100-s01729,dense,100,1729,finite-time/observation/k-10,0.0002464165008859709,1.9645995052997023e-05,0.00022348999118548818,0.0002630835078889504,0.00022852050460642204,0.00025893749989336357,30 +pydtmc,dense-n0100-s01729,dense,100,1729,finite-time/observation/k-100,0.0006311459947028197,2.6687492209021002e-05,0.000602510499447817,0.0006465212536568288,0.0006049790026736446,0.0006427080006687902,30 +pydtmc,dense-n0100-s01729,dense,100,1729,finite-time/step,1.4479010133072734e-05,2.5834888219833374e-06,1.2187254469608888e-05,1.7072750779334456e-05,1.3790995581075549e-05,1.643750147195533e-05,30 +pydtmc,dense-n0100-s01729,dense,100,1729,hitting-probability/cold-all-states,0.0010548540012678131,3.181200008839369e-05,0.001025677254801849,0.0010868120043596718,0.0010310414945706725,0.001075001044227974,30 +pydtmc,dense-n0100-s01729,dense,100,1729,hitting-time/cold-all-states,0.002026937494520098,5.2041999879293144e-05,0.00199883375535137,0.0021010210002714302,0.002007562499784399,0.002080229503917508,30 +pydtmc,dense-n0100-s01729,dense,100,1729,hitting/bounded/at-most/k-10,0.00030518750281771645,1.685399911366403e-05,0.0002884480054490268,0.00031910425241221674,0.00029579100373666734,0.0003158545005135238,30 +pydtmc,dense-n0100-s01729,dense,100,1729,hitting/bounded/at-most/k-100,0.0020411665027495474,5.420899105956778e-05,0.001987208495847881,0.002089906749461079,0.0020102709968341514,0.0020681255045928992,30 +pydtmc,dense-n0100-s01729,dense,100,1729,hitting/bounded/exact/k-10,0.00029462499514920637,2.272899291710928e-05,0.0002714477523113601,0.0003147292518406175,0.0002735835005296394,0.0003108750097453594,30 +pydtmc,dense-n0100-s01729,dense,100,1729,hitting/bounded/exact/k-100,0.002177083501010202,9.485399641562253e-05,0.0020752605014422443,0.0022612499924434815,0.0021009789925301448,0.002222604503913317,30 +pydtmc,dense-n0100-s01729,dense,100,1729,hitting/bounded/greater-than/k-10,0.0002978329939651303,1.8104503396898508e-05,0.00028567699700943194,0.00033377075305907056,0.0002914380020229146,0.00032270362480630856,30 +pydtmc,dense-n0100-s01729,dense,100,1729,hitting/bounded/greater-than/k-100,0.0020392085061757825,0.0001334784901700914,0.0019663749990286306,0.002186989750043722,0.001989791497180704,0.002172686996345874,30 +pydtmc,dense-n0100-s01729,dense,100,1729,power/10,0.006152146001113579,0.00029356200684560463,0.005876375245861709,0.006462167002609931,0.006052583499695174,0.0063707500012242235,30 +pydtmc,dense-n0100-s01729,dense,100,1729,power/100,0.0064518954968662,0.00022866599465487525,0.006278562254010467,0.006715822746627964,0.006295833503827453,0.006654541997704655,30 +pydtmc,dense-n0100-s01729,dense,100,1729,power/2,0.006087187495722901,0.0003436250117374584,0.005810197999380762,0.00643321875759284,0.005850271001690999,0.006368604495946784,30 +pydtmc,dense-n0100-s01729,dense,100,1729,race/forward-committor,0.011950771004194394,0.00035289600782562047,0.011740947989892447,0.012525041507615242,0.011882083497766871,0.012238582989084534,30 +pydtmc,dense-n0100-s01729,dense,100,1729,return/bounded/k-10,0.0002791044971672818,9.937008144333959e-06,0.0002611047493701335,0.0002846667448466178,0.0002695420043892227,0.00028427100187400356,30 +pydtmc,dense-n0100-s01729,dense,100,1729,return/bounded/k-100,0.002034458506386727,8.858351066010073e-05,0.0019461559895717073,0.0021179272553126793,0.0019754169989028014,0.0020847495034104213,30 +pydtmc,dense-n0100-s01729,dense,100,1729,return/mean-recurrence,0.012797353992937133,0.00019016650185221806,0.012687135007581674,0.0135539164984948,0.012709228991298005,0.013465041505696718,30 +pydtmc,dense-n0100-s01729,dense,100,1729,simulation/10000,0.11571710449788952,0.008452937501715496,0.1042767807484779,0.12276999974710634,0.11167312500765547,0.11864254149986664,30 +pydtmc,dense-n0100-s01729,dense,100,1729,simulation/100000,1.0532707710008253,0.03220937500009313,1.0173496045026695,1.079192270997737,1.0329074374967604,1.0644444169884082,30 +pydtmc,dense-n0100-s01729,dense,100,1729,stationary,0.0031287500023609027,9.1562993475236e-05,0.00308412474259967,0.003264447754190769,0.0030931459987186827,0.0032432824691568385,30 +pydtmc,dense-n0100-s01729,dense,100,1729,structure/classes-cold,0.0020403539965627715,8.16670071799308e-05,0.0019902082494809292,0.002158322498871712,0.0020037499998579733,0.002137083007255569,30 +pydtmc,dense-n0100-s01729,dense,100,1729,structure/classes-lifecycle,0.017781000002287328,0.0006202500080689788,0.01721177149374853,0.018413978494209005,0.017256229002668988,0.01818518749496434,30 +pydtmc,dense-n0100-s01729,dense,100,1729,structure/classes-warm/access,2.550750505179167e-07,3.5583005228545265e-09,2.5170730004902e-07,2.583624504040926e-07,2.5271455015172253e-07,2.568821364911855e-07,30 +pydtmc,dense-n0100-s01729,dense,100,1729,structure/classes-warm/consumed,7.064327050466091e-06,1.460604493331628e-07,6.957313575185254e-06,7.211856249705306e-06,6.975285449880176e-06,7.142137549089966e-06,30 +pydtmc,dense-n0100-s01729,dense,100,1729,structure/irreducible-cold,0.002086353997583501,0.0001428955001756549,0.001996406244870741,0.002517822493246058,0.0020356870008981787,0.0024557915021432564,30 +pydtmc,dense-n0100-s01729,dense,100,1729,structure/irreducible-warm,2.7295830004732125e-07,3.064649354200808e-09,2.723531248193467e-07,2.7802087606687563e-07,2.7261665018158966e-07,2.765965599246556e-07,30 +pydtmc,dense-n0100-s01729,dense,100,1729,visits/bounded-expectation/k-10,0.0001583125049364753,6.542009941767901e-06,0.00015385475126095116,0.00017072899572667666,0.00015587292600685032,0.00016666699229972437,30 +pydtmc,dense-n0100-s01729,dense,100,1729,visits/bounded-expectation/k-100,0.00033935449027922004,1.5666504623368382e-05,0.0003268020009272732,0.0003624062483140733,0.0003306250073364936,0.000354812502337154,30 +pydtmc,dense-n0100-s02718,dense,100,2718,construction/public-consumed,0.012627187490579672,9.216649777954444e-05,0.01253701050154632,0.012719301746983547,0.012549270999443252,0.012705542001640424,30 +pydtmc,dense-n0100-s02718,dense,100,2718,evolution/k-10,0.00013922899233875796,2.0834995666518807e-06,0.0001384684983349871,0.00014277049922384322,0.0001386459989589639,0.0001419159962097183,30 +pydtmc,dense-n0100-s02718,dense,100,2718,evolution/k-100,0.00044277100096223876,3.4580007195472717e-06,0.0004404477440402843,0.0004493544947763439,0.00044108300062362105,0.00044637449900619686,30 +pydtmc,dense-n0100-s02718,dense,100,2718,evolution/one-step,0.00010929149721050635,2.2500025806948543e-06,0.00010802049655467272,0.0001124067566706799,0.00010833293854375369,0.00011143750452902168,30 +pydtmc,dense-n0100-s02718,dense,100,2718,finite-time/n-step/k-10,0.0001374790008412674,1.4170072972774506e-06,0.0001363339979434386,0.0001396040061081294,0.00013706300524063408,0.00013841599866282195,30 +pydtmc,dense-n0100-s02718,dense,100,2718,finite-time/n-step/k-100,0.00044229150080354884,2.3129978217184544e-06,0.0004395102478156332,0.000443676755821798,0.0004408114753459813,0.00044314599654171616,30 +pydtmc,dense-n0100-s02718,dense,100,2718,finite-time/observation/k-10,0.00014018749789102003,2.103501174133271e-06,0.00013822974869981408,0.00014559325791196898,0.00013833350385539234,0.00014108300092630088,30 +pydtmc,dense-n0100-s02718,dense,100,2718,finite-time/observation/k-100,0.0004394374991534278,3.3959950087592006e-06,0.00043771875061793253,0.00044406224333215505,0.0004381874969112687,0.00044275155760260533,30 +pydtmc,dense-n0100-s02718,dense,100,2718,finite-time/step,3.104491042904556e-06,1.4648685464635491e-07,2.9582552087958902e-06,3.37450546794571e-06,2.9794973670504987e-06,3.25000291923061e-06,30 +pydtmc,dense-n0100-s02718,dense,100,2718,hitting-probability/cold-all-states,0.000799166999058798,4.18750278186053e-06,0.0007955314977152739,0.0008056045044213533,0.0007962704985402524,0.0008032500045374036,30 +pydtmc,dense-n0100-s02718,dense,100,2718,hitting-time/cold-all-states,0.0015923335013212636,4.771500243805349e-06,0.0015881149920460302,0.001597613994817948,0.0015892914962023497,0.0015965000056894496,30 +pydtmc,dense-n0100-s02718,dense,100,2718,hitting/bounded/at-most/k-10,0.00017966649465961382,1.4784891391173005e-06,0.00017813600788940676,0.00018072850070893764,0.00017843800014816225,0.00018043749878415838,30 +pydtmc,dense-n0100-s02718,dense,100,2718,hitting/bounded/at-most/k-100,0.0017140210038633086,8.39599670143798e-06,0.0017041772516677156,0.0017182190094899852,0.0017084374921978451,0.0017169789934996516,30 +pydtmc,dense-n0100-s02718,dense,100,2718,hitting/bounded/exact/k-10,0.0001797914956114255,4.3330073822289705e-06,0.00017663549442659132,0.00019167749996995553,0.00017708299856167287,0.0001901875075418502,30 +pydtmc,dense-n0100-s02718,dense,100,2718,hitting/bounded/exact/k-100,0.0017032079995260574,7.061993528623134e-06,0.0016973439996945672,0.0017257604959013406,0.0016982915039989166,0.0017128129984484985,30 +pydtmc,dense-n0100-s02718,dense,100,2718,hitting/bounded/greater-than/k-10,0.00018047950288746506,1.5834957594051957e-06,0.00017906275752466172,0.0001821767546061892,0.0001793750052456744,0.0001812089976738207,30 +pydtmc,dense-n0100-s02718,dense,100,2718,hitting/bounded/greater-than/k-100,0.001707479495962616,7.499998901039362e-06,0.0017018749967974145,0.0017182599949592259,0.0017027290014084429,0.001715937498374842,30 +pydtmc,dense-n0100-s02718,dense,100,2718,power/10,0.00487945850181859,5.314600275596604e-05,0.004829781250009546,0.004932417006784817,0.004844458992010914,0.0049146040037157945,30 +pydtmc,dense-n0100-s02718,dense,100,2718,power/100,0.004859271000896115,4.7562498366460204e-05,0.004812698003661353,0.004931978757667821,0.004813833504158538,0.004902166503597982,30 +pydtmc,dense-n0100-s02718,dense,100,2718,power/2,0.0048346870025852695,8.414600597461686e-05,0.004738895993796177,0.004878927502431907,0.004755166497488972,0.004856374493101612,30 +pydtmc,dense-n0100-s02718,dense,100,2718,race/forward-committor,0.009359396004583687,3.21039988193661e-05,0.009319572745880578,0.009376864989462774,0.00932937499601394,0.009372000000439584,30 +pydtmc,dense-n0100-s02718,dense,100,2718,return/bounded/k-10,0.0001772914984030649,1.2499949662014842e-06,0.0001762192478054203,0.0001790524911484681,0.00017647950153332204,0.00017822899826569483,30 +pydtmc,dense-n0100-s02718,dense,100,2718,return/bounded/k-100,0.0016953334998106584,6.916998245287687e-06,0.0016911147540668026,0.0017034582451742608,0.001692291501967702,0.0017005420013447292,30 +pydtmc,dense-n0100-s02718,dense,100,2718,return/mean-recurrence,0.009969541992177255,5.4666990763507783e-05,0.009925625006871996,0.010055125258077169,0.009932749992003664,0.010040083507192321,30 +pydtmc,dense-n0100-s02718,dense,100,2718,simulation/10000,0.08480895800312283,0.00042145800398429856,0.08439474975239136,0.08526596824231092,0.0845936459954828,0.08509020849305671,30 +pydtmc,dense-n0100-s02718,dense,100,2718,simulation/100000,0.8432229999962146,0.0068778749846387655,0.8371101977536455,0.8603457600038382,0.8395811045047594,0.8524677919922397,30 +pydtmc,dense-n0100-s02718,dense,100,2718,stationary,0.002649250003742054,1.7166996258310974e-05,0.0026360422525613103,0.0027577705041039735,0.0026460829976713285,0.0027083750028396025,30 +pydtmc,dense-n0100-s02718,dense,100,2718,structure/classes-cold,0.0016525414976058528,2.1396001102402806e-05,0.0016299795024679042,0.001671885751420632,0.001645479496801272,0.0016698545005056076,30 +pydtmc,dense-n0100-s02718,dense,100,2718,structure/classes-lifecycle,0.014553187000274193,8.935399819165468e-05,0.014461978997132974,0.014636916497693164,0.014487271000689361,0.014618249995692167,30 +pydtmc,dense-n0100-s02718,dense,100,2718,structure/classes-warm/access,2.1868335024919362e-07,9.166506060864929e-10,2.1797077461087613e-07,2.4859165023372046e-07,2.1835415027453565e-07,2.3410834983224049e-07,30 +pydtmc,dense-n0100-s02718,dense,100,2718,structure/classes-warm/consumed,5.588514549890532e-06,1.0802049655466797e-08,5.579613499139669e-06,5.60997607462923e-06,5.580662450665841e-06,5.599804199300707e-06,30 +pydtmc,dense-n0100-s02718,dense,100,2718,structure/irreducible-cold,0.001687625001068227,1.3249999028630555e-05,0.0016760520011303015,0.0017021664898493327,0.0016777705022832379,0.0017008124996209517,30 +pydtmc,dense-n0100-s02718,dense,100,2718,structure/irreducible-warm,2.2785004985053091e-07,3.0624505598098013e-09,2.25502125613275e-07,2.447968250635313e-07,2.2574995018658224e-07,2.3832084989408032e-07,30 +pydtmc,dense-n0100-s02718,dense,100,2718,visits/bounded-expectation/k-10,9.670849976828322e-05,1.1665033525787294e-06,9.594775110599585e-05,9.800000407267362e-05,9.627100371289998e-05,9.783300629351288e-05,30 +pydtmc,dense-n0100-s02718,dense,100,2718,visits/bounded-expectation/k-100,0.00022679199901176617,1.396001607645303e-06,0.0002259167522424832,0.00022839549637865275,0.0002262505004182458,0.00022806200286140665,30 +pydtmc,dense-n0100-s31415,dense,100,31415,construction/public-consumed,0.012762667000060901,0.0001796255019144155,0.01257530199654866,0.012892281250969972,0.012583041498146486,0.012829396000597626,30 +pydtmc,dense-n0100-s31415,dense,100,31415,evolution/k-10,0.0001398330059600994,1.4164979802444577e-06,0.00013904199659009464,0.0001432295102858916,0.00013925000512244877,0.00014295800065156072,30 +pydtmc,dense-n0100-s31415,dense,100,31415,evolution/k-100,0.00044489599531516433,2.937500539701432e-06,0.00044283374154474586,0.00044962474930798635,0.0004433330032043159,0.00044712499948218465,30 +pydtmc,dense-n0100-s31415,dense,100,31415,evolution/one-step,0.00010843750351341441,2.4170076358132064e-06,0.00010592725084279664,0.00010959375504171476,0.00010616649524308741,0.0001093754981411621,30 +pydtmc,dense-n0100-s31415,dense,100,31415,finite-time/n-step/k-10,0.0001387704978697002,1.2504970072768629e-06,0.00013782324822386727,0.00014036475113243796,0.00013806249626213685,0.00013979199866298586,30 +pydtmc,dense-n0100-s31415,dense,100,31415,finite-time/n-step/k-100,0.0004436255039763637,3.8124999264255166e-06,0.00044019825145369396,0.0004476355061342474,0.00044099999649915844,0.00044608300959225744,30 +pydtmc,dense-n0100-s31415,dense,100,31415,finite-time/observation/k-10,0.0001385630021104589,1.5839978004805744e-06,0.00013720800052396953,0.00014063550770515576,0.0001377085063722916,0.00013941600627731532,30 +pydtmc,dense-n0100-s31415,dense,100,31415,finite-time/observation/k-100,0.0004423335049068555,2.416003553662449e-06,0.0004409692519402597,0.00044715599142364226,0.0004411864832945867,0.0004451455024536699,30 +pydtmc,dense-n0100-s31415,dense,100,31415,finite-time/step,3.083005140069872e-06,1.2500822776928544e-07,2.9692491807509214e-06,3.281493263784796e-06,3.000008291564882e-06,3.2289972295984626e-06,30 +pydtmc,dense-n0100-s31415,dense,100,31415,hitting-probability/cold-all-states,0.000797416505520232,2.604501787573099e-06,0.0007954585016705096,0.0008008752520254347,0.0007962290037539788,0.0007987709977896884,30 +pydtmc,dense-n0100-s31415,dense,100,31415,hitting-time/cold-all-states,0.001598062000994105,8.167000487446785e-06,0.0015919167490210384,0.0016088232478068676,0.001593374996446073,0.0016036875022109598,30 +pydtmc,dense-n0100-s31415,dense,100,31415,hitting/bounded/at-most/k-10,0.00018027049372904003,1.7290003597736359e-06,0.00017844825197244063,0.0001817084885260556,0.0001789164962247014,0.00018099999579135329,30 +pydtmc,dense-n0100-s31415,dense,100,31415,hitting/bounded/at-most/k-100,0.0017180210052174516,1.1479496606625617e-05,0.0017042397521436214,0.0017284589921473525,0.0017102080018958077,0.001723520501400344,30 +pydtmc,dense-n0100-s31415,dense,100,31415,hitting/bounded/exact/k-10,0.00017772949649952352,1.5420009731315076e-06,0.00017620899961912073,0.00017989649859373458,0.00017647900676820427,0.00017866650159703568,30 +pydtmc,dense-n0100-s31415,dense,100,31415,hitting/bounded/exact/k-100,0.0017042290055542253,8.146009349729866e-06,0.0016993014942272566,0.0017133122601080686,0.00170133299252484,0.0017112915011239238,30 +pydtmc,dense-n0100-s31415,dense,100,31415,hitting/bounded/greater-than/k-10,0.00018004100274993107,1.1049996828660369e-06,0.00017907225264934823,0.0001825102481234353,0.00017941600526683033,0.0001811460024327971,30 +pydtmc,dense-n0100-s31415,dense,100,31415,hitting/bounded/greater-than/k-100,0.0017091039990191348,4.499997885432094e-06,0.0017060002428479493,0.001713812496745959,0.0017069585010176525,0.001711979006358888,30 +pydtmc,dense-n0100-s31415,dense,100,31415,power/10,0.004727604493382387,4.764599725604057e-05,0.004694989504059777,0.004821062258997699,0.004708416992798448,0.004755020498123486,30 +pydtmc,dense-n0100-s31415,dense,100,31415,power/100,0.004773770502652042,3.504099731799215e-05,0.004747906750708353,0.004873010253504617,0.004753416986204684,0.004857396001170855,30 +pydtmc,dense-n0100-s31415,dense,100,31415,power/2,0.004829291996429674,7.16875001671724e-05,0.004747791746922303,0.0048830835075932555,0.00475860400183592,0.0048662289991625585,30 +pydtmc,dense-n0100-s31415,dense,100,31415,race/forward-committor,0.00943741700029932,6.699949881294742e-05,0.009338083502370864,0.009497802002442768,0.009372783999788225,0.009486687500611879,30 +pydtmc,dense-n0100-s31415,dense,100,31415,return/bounded/k-10,0.0001763540058163926,6.875052349641919e-07,0.0001757395002641715,0.00017718699018587358,0.00017591701180208474,0.0001768334986991249,30 +pydtmc,dense-n0100-s31415,dense,100,31415,return/bounded/k-100,0.0016927289980230853,7.813003321643919e-06,0.0016840832504385617,0.0016989690011541825,0.0016864585049916059,0.0016955204991973005,30 +pydtmc,dense-n0100-s31415,dense,100,31415,return/mean-recurrence,0.009990625498176087,7.706249743932858e-05,0.009915010257827817,0.010063572757644579,0.009966207988327369,0.01003929199941922,30 +pydtmc,dense-n0100-s31415,dense,100,31415,simulation/10000,0.08498156249697786,0.0003841880024992861,0.08372468775269226,0.08521370874950662,0.08419360451080138,0.08511883350001881,30 +pydtmc,dense-n0100-s31415,dense,100,31415,simulation/100000,0.870300437505648,0.003454812991549261,0.8504130102519412,0.8722133850023965,0.8599053330035531,0.8717620000024908,30 +pydtmc,dense-n0100-s31415,dense,100,31415,stationary,0.0026417709959787317,1.4479497622232884e-05,0.002630104499985464,0.0026591767455101945,0.0026318754971725866,0.0026547505040070973,30 +pydtmc,dense-n0100-s31415,dense,100,31415,structure/classes-cold,0.0016836665017763153,1.6438003513030708e-05,0.001653635252296226,0.0016989692485367414,0.001678499989793636,0.0016970839933492243,30 +pydtmc,dense-n0100-s31415,dense,100,31415,structure/classes-lifecycle,0.014584416996513028,6.731250323355198e-05,0.014536823502567131,0.01465743751032278,0.014542771001288202,0.014627583004767075,30 +pydtmc,dense-n0100-s31415,dense,100,31415,structure/classes-warm/access,2.1626254965667615e-07,6.104004569351381e-10,2.158104005502537e-07,2.168781753425719e-07,2.1597290033241732e-07,2.1682914957636966e-07,30 +pydtmc,dense-n0100-s31415,dense,100,31415,structure/classes-warm/consumed,5.590114599908702e-06,2.2493749565910632e-08,5.569864575954852e-06,5.6280104254256e-06,5.575604150362779e-06,5.611200000566896e-06,30 +pydtmc,dense-n0100-s31415,dense,100,31415,structure/irreducible-cold,0.0016713545119273476,6.104004569351673e-06,0.0016655832405376714,0.0016765829968790058,0.0016686460003256798,0.0016751249931985512,30 +pydtmc,dense-n0100-s31415,dense,100,31415,structure/irreducible-warm,2.260312503494788e-07,1.0124502296093773e-09,2.2546144973603079e-07,2.389844248682493e-07,2.2557080008482444e-07,2.3296459985431282e-07,30 +pydtmc,dense-n0100-s31415,dense,100,31415,visits/bounded-expectation/k-10,9.76250012172386e-05,1.396001607645303e-06,9.658300041337498e-05,9.947874423232861e-05,9.69795000855811e-05,9.82704950729385e-05,30 +pydtmc,dense-n0100-s31415,dense,100,31415,visits/bounded-expectation/k-100,0.00022850000823382288,1.6665071598254144e-06,0.00022722900394001044,0.00023042748944135383,0.00022747899492969736,0.00022985449322732165,30 +pydtmc,dense-n0250-s01729,dense,250,1729,construction/public-consumed,0.07826112499606097,0.00023247899662237614,0.07808091625702218,0.07869762500922661,0.07814395800232887,0.07866395640285191,30 +pydtmc,dense-n0250-s01729,dense,250,1729,evolution/k-10,0.0004438955002115108,2.4208500690292567e-05,0.0004119795048609376,0.0004655624979932327,0.00042039549589389935,0.000463395997940097,30 +pydtmc,dense-n0250-s01729,dense,250,1729,evolution/k-100,0.0014124789959168993,3.341649426147342e-05,0.001388968503306387,0.0014821877448412124,0.001400520995957777,0.0014569164995918982,30 +pydtmc,dense-n0250-s01729,dense,250,1729,evolution/one-step,0.000331916511640884,1.431250711902976e-05,0.0003224274914828129,0.00036139649819233455,0.00032283349719364196,0.00034433300606906414,30 +pydtmc,dense-n0250-s01729,dense,250,1729,hitting-probability/cold-all-states,0.010867770506592933,0.00012029150093439966,0.01079626049977378,0.011014739247912075,0.010820311996212695,0.01094483349879738,30 +pydtmc,dense-n0250-s01729,dense,250,1729,hitting-time/cold-all-states,0.020983250004064757,9.383350698044524e-05,0.020898864491755376,0.02110502073992393,0.02090991649311036,0.021036832993559074,30 +pydtmc,dense-n0250-s01729,dense,250,1729,power/10,0.029491520501323976,0.00020347950339782983,0.02928704099758761,0.029673291493963916,0.029390937503194436,0.029649896001501475,30 +pydtmc,dense-n0250-s01729,dense,250,1729,power/100,0.029938208499515895,0.00027897900145035237,0.029685396006243536,0.03023000050961855,0.02973372899577953,0.03019549999589799,30 +pydtmc,dense-n0250-s01729,dense,250,1729,power/2,0.02920604150131112,0.00018510450172470883,0.02911418800795218,0.029590291745989816,0.029127354006050155,0.02950033300294308,30 +pydtmc,dense-n0250-s01729,dense,250,1729,race/forward-committor,0.0577328334984486,0.00016091650468297303,0.0573546872510633,0.057857375242747366,0.057672395996632986,0.05780012499599252,30 +pydtmc,dense-n0250-s01729,dense,250,1729,return/mean-recurrence,0.058641146002628375,0.00019010400137631223,0.058300979748310056,0.05875485400611069,0.058462666493142024,0.058688625002105255,30 +pydtmc,dense-n0250-s01729,dense,250,1729,simulation/10000,0.09803074999945238,0.00041639550181571394,0.09779823950157152,0.0986363647498365,0.09789335400273558,0.09853756250231527,30 +pydtmc,dense-n0250-s01729,dense,250,1729,simulation/100000,0.9780213125050068,0.00757558349869214,0.9579014482478669,0.9830753640017065,0.9677763749932637,0.9810829994967207,30 +pydtmc,dense-n0250-s01729,dense,250,1729,stationary,0.01805920850165421,0.000432624998211395,0.01727821874737856,0.018365166492003482,0.017491806045654812,0.0182312085016747,30 +pydtmc,dense-n0250-s01729,dense,250,1729,structure/classes-cold,0.010093187498569023,5.281249468680471e-05,0.01002521824921132,0.010130573500646278,0.010037145504611544,0.010126041503099259,30 +pydtmc,dense-n0250-s01729,dense,250,1729,structure/classes-lifecycle,0.09183522899547825,0.0007467914911103435,0.09123733350133989,0.09327192749697133,0.09128604150464525,0.09263091700267978,30 +pydtmc,dense-n0250-s01729,dense,250,1729,structure/classes-warm/access,2.1706044935854153e-07,7.937996997497987e-10,2.1646977475029417e-07,2.1798649977426976e-07,2.1667294931830836e-07,2.177042006223928e-07,30 +pydtmc,dense-n0250-s01729,dense,250,1729,structure/classes-warm/consumed,1.3598712549719494e-05,1.4541880009346662e-07,1.3509733374667122e-05,1.3922430148886633e-05,1.3540754199493676e-05,1.3917517014288024e-05,30 +pydtmc,dense-n0250-s01729,dense,250,1729,structure/irreducible-cold,0.010015458501584362,0.00012499999138526618,0.009932114255207125,0.010511020500416635,0.009947750491846818,0.010218208495643921,30 +pydtmc,dense-n0250-s01729,dense,250,1729,structure/irreducible-warm,2.3360204941127451e-07,3.199999628122892e-09,2.3033747565932572e-07,2.3646247536817102e-07,2.3122295024222695e-07,2.3558540051453747e-07,30 +pydtmc,dense-n0250-s02718,dense,250,2718,construction/public-consumed,0.0818730004975805,0.001524937993963249,0.08054843750142027,0.08468975049981964,0.0809328750037821,0.08296716699260287,30 +pydtmc,dense-n0250-s02718,dense,250,2718,evolution/k-10,0.0004233744984958321,2.197849244112149e-05,0.0004077080047864001,0.00045555225369753316,0.00041097899520536885,0.0004481255018617958,30 +pydtmc,dense-n0250-s02718,dense,250,2718,evolution/k-100,0.001375708008708898,4.418750904733315e-05,0.0013312392475199886,0.0014188642489898484,0.0013392079999903217,0.0014122920038062148,30 +pydtmc,dense-n0250-s02718,dense,250,2718,evolution/one-step,0.0003711459939950146,2.0062507246620953e-05,0.00035653099621413276,0.0003960937392548658,0.0003606454993132502,0.00039120850124163553,30 +pydtmc,dense-n0250-s02718,dense,250,2718,hitting-probability/cold-all-states,0.010527249993174337,4.977099160896614e-05,0.010486738992767641,0.010583041988866171,0.01050356250925688,0.010557396002695896,30 +pydtmc,dense-n0250-s02718,dense,250,2718,hitting-time/cold-all-states,0.020872936998785008,5.562500155065209e-05,0.020822583501285408,0.020937240002240287,0.02082624999457039,0.020921958013786934,30 +pydtmc,dense-n0250-s02718,dense,250,2718,power/10,0.029484000493539497,0.00021789551101392135,0.029147198001737706,0.029659624753548997,0.029268353995576035,0.029593167011626065,30 +pydtmc,dense-n0250-s02718,dense,250,2718,power/100,0.030063270998653024,0.0002285209993715398,0.02978163500665687,0.030224655747588258,0.029931978999229614,0.03017412500048522,30 +pydtmc,dense-n0250-s02718,dense,250,2718,power/2,0.02952437500061933,0.00017806249525165185,0.029358187999605434,0.029692469241126673,0.029387145994405728,0.029620145498483907,30 +pydtmc,dense-n0250-s02718,dense,250,2718,race/forward-committor,0.05709483299870044,0.000176646004547365,0.056537416498031234,0.057247457745688735,0.05672972899628803,0.057206520992622245,30 +pydtmc,dense-n0250-s02718,dense,250,2718,return/mean-recurrence,0.058563646001857705,0.00018891649961005896,0.05841685375344241,0.05883597875072155,0.05845079199934844,0.05862347899528686,30 +pydtmc,dense-n0250-s02718,dense,250,2718,simulation/10000,0.09992664550372865,0.002082459002849646,0.09735680225276155,0.10114730200803024,0.09830947950104019,0.10088843749690568,30 +pydtmc,dense-n0250-s02718,dense,250,2718,simulation/100000,0.9720035204882151,0.0031025005009723827,0.9688052077508473,0.9741889062424889,0.9701707080021151,0.9737311665012385,30 +pydtmc,dense-n0250-s02718,dense,250,2718,stationary,0.01706808299786644,4.777150024892762e-05,0.017031979252351448,0.01711776074807858,0.01704058350151172,0.01709514600224793,30 +pydtmc,dense-n0250-s02718,dense,250,2718,structure/classes-cold,0.010294729501765687,0.00010577099601505324,0.010188166757870931,0.010380114243162097,0.010197978997894097,0.010360145999584347,30 +pydtmc,dense-n0250-s02718,dense,250,2718,structure/classes-lifecycle,0.09353493750677444,0.0031450835085706785,0.09049884399792063,0.09677145825116895,0.09077291650464758,0.09460050902944203,30 +pydtmc,dense-n0250-s02718,dense,250,2718,structure/classes-warm/access,2.1854379956494087e-07,1.8166996596846803e-09,2.1661354985553773e-07,2.1940627448202576e-07,2.1738755021942777e-07,2.1891249998589045e-07,30 +pydtmc,dense-n0250-s02718,dense,250,2718,structure/classes-warm/consumed,1.3565885400021217e-05,4.221875060466276e-08,1.3520428175252164e-05,1.3601755199488252e-05,1.3532616649899864e-05,1.3590333350293804e-05,30 +pydtmc,dense-n0250-s02718,dense,250,2718,structure/irreducible-cold,0.0100621255041915,3.3771000744309276e-05,0.010050708002381725,0.010119072492670966,0.010055457998532802,0.010080312997160945,30 +pydtmc,dense-n0250-s02718,dense,250,2718,structure/irreducible-warm,2.21583300299244e-07,7.645998266525753e-10,2.2073542495490982e-07,2.222666749730706e-07,2.209020996815525e-07,2.2210209936019965e-07,30 +pydtmc,dense-n0250-s31415,dense,250,31415,construction/public-consumed,0.07873002049745992,0.00021683300292352214,0.07847690624475945,0.07891181224840693,0.07858400000986876,0.07884610449400498,30 +pydtmc,dense-n0250-s31415,dense,250,31415,evolution/k-10,0.0004046245012432337,4.103501851204783e-06,0.0004010942539025564,0.00040961500417324714,0.00040252049802802503,0.0004071459989063442,30 +pydtmc,dense-n0250-s31415,dense,250,31415,evolution/k-100,0.0013700005074497312,3.8894992030691355e-05,0.0013373544934438542,0.001409760250680847,0.0013431254992610775,0.001394250000885222,30 +pydtmc,dense-n0250-s31415,dense,250,31415,evolution/one-step,0.00031237499933922663,5.103989678900689e-06,0.00030908299959264696,0.00031939574546413496,0.0003101249967585318,0.00031470900285057724,30 +pydtmc,dense-n0250-s31415,dense,250,31415,hitting-probability/cold-all-states,0.010544561999267898,4.4208492909092456e-05,0.010515447746001882,0.0106110307497147,0.010524208497372456,0.010592749997158535,30 +pydtmc,dense-n0250-s31415,dense,250,31415,hitting-time/cold-all-states,0.021321167005226016,0.0002879585008486174,0.021029582752817078,0.021570426753896754,0.02110835400526412,0.021416228999441955,30 +pydtmc,dense-n0250-s31415,dense,250,31415,power/10,0.030369729502126575,0.00038870850403327495,0.03003186500063748,0.032356729247112526,0.030105979494692292,0.031580332994053606,30 +pydtmc,dense-n0250-s31415,dense,250,31415,power/100,0.03010310399986338,0.00023466649872716516,0.02991829199163476,0.03049487499447423,0.029967021007905714,0.030321250000270084,30 +pydtmc,dense-n0250-s31415,dense,250,31415,power/2,0.0296313960061525,0.0003852494992315769,0.02929425999900559,0.030112114745861618,0.029389657648061982,0.029801833996316418,30 +pydtmc,dense-n0250-s31415,dense,250,31415,race/forward-committor,0.057677499498822726,0.0005654579945257865,0.05715381248955964,0.05977051024456159,0.057242541006417014,0.058396874999743886,30 +pydtmc,dense-n0250-s31415,dense,250,31415,return/mean-recurrence,0.05937983349576825,0.0010980834922520444,0.058501812745817006,0.06109463549364591,0.058601833501597866,0.060435083498305175,30 +pydtmc,dense-n0250-s31415,dense,250,31415,simulation/10000,0.09794677099853288,0.001035250497807283,0.09716202100389637,0.1006012084944814,0.0975735004976741,0.09991897950385464,30 +pydtmc,dense-n0250-s31415,dense,250,31415,simulation/100000,0.9831543335021706,0.00731108350737486,0.9777011352525733,1.000967749994743,0.97978877100104,0.9927483335050056,30 +pydtmc,dense-n0250-s31415,dense,250,31415,stationary,0.017324375003227033,0.00016418749873992056,0.017169229504361283,0.01753183299661032,0.017217375003383495,0.01742762500362005,30 +pydtmc,dense-n0250-s31415,dense,250,31415,structure/classes-cold,0.010119541992025916,4.527051351033151e-05,0.010054010246676626,0.010161510999751044,0.010099145991262048,0.0101552320893461,30 +pydtmc,dense-n0250-s31415,dense,250,31415,structure/classes-lifecycle,0.09071160400344525,0.00037877100839978084,0.09043785425456008,0.09111278100317577,0.09052883350523189,0.0910319789982168,30 +pydtmc,dense-n0250-s31415,dense,250,31415,structure/classes-warm/access,2.1717289928346875e-07,3.958492015954103e-10,2.168187755160034e-07,2.1775099994556514e-07,2.1691449914214898e-07,2.1747777729615334e-07,30 +pydtmc,dense-n0250-s31415,dense,250,31415,structure/classes-warm/consumed,1.360433540030499e-05,6.439165081246697e-08,1.3548153099327464e-05,1.3741681275496376e-05,1.3582616699568461e-05,1.3680214600026376e-05,30 +pydtmc,dense-n0250-s31415,dense,250,31415,structure/irreducible-cold,0.010056396495201625,8.427049760939553e-05,0.00998134374822257,0.010185083254327765,0.010019832996476907,0.010098515788195072,30 +pydtmc,dense-n0250-s31415,dense,250,31415,structure/irreducible-warm,2.2236459990381263e-07,6.562499038409516e-10,2.217302251665387e-07,2.2317190014291554e-07,2.2184170011314563e-07,2.2285000013653188e-07,30 +pydtmc,dense-n0500-s01729,dense,500,1729,construction/public-consumed,0.3227095624897629,0.002158312505343929,0.3204876874879119,0.3246598960031406,0.32106793700222624,0.324356645498483,30 +pydtmc,dense-n0500-s01729,dense,500,1729,evolution/k-10,0.0010226039958070032,8.332994184456766e-06,0.0010173022492381278,0.0010354375044698827,0.0010175415009143762,0.0010314579994883388,30 +pydtmc,dense-n0500-s01729,dense,500,1729,evolution/k-100,0.004114479503186885,1.7707992810755968e-05,0.004101718506717589,0.004132479254622012,0.004108749999431893,0.00412885399418883,30 +pydtmc,dense-n0500-s01729,dense,500,1729,evolution/one-step,0.0007285000028787181,1.4062497939448804e-05,0.000715604008291848,0.0007465210073860362,0.0007197084996732883,0.0007347692619077861,30 +pydtmc,dense-n0500-s01729,dense,500,1729,hitting-probability/cold-all-states,0.07557504149735905,6.575000588782132e-05,0.07553281225409592,0.0756644060020335,0.07554268799867714,0.07563825001125224,30 +pydtmc,dense-n0500-s01729,dense,500,1729,hitting-time/cold-all-states,0.1507608540050569,0.00027239599876338616,0.15065259400580544,0.15173342649723054,0.1507151249970775,0.15135177049523918,30 +pydtmc,dense-n0500-s01729,dense,500,1729,power/10,0.12446356299915351,0.0005111259961267933,0.12425042675386067,0.12549201074216398,0.124281707991031,0.12493541700678179,30 +pydtmc,dense-n0500-s01729,dense,500,1729,power/100,0.1278199790031067,0.0009254169999621809,0.12687359350093175,0.1281177920063783,0.12700037499598693,0.12802508349705022,30 +pydtmc,dense-n0500-s01729,dense,500,1729,power/2,0.12084912499994971,0.0003659584981505759,0.12060073950851802,0.12140121875199839,0.12062585400417447,0.1212015199685993,30 +pydtmc,dense-n0500-s01729,dense,500,1729,race/forward-committor,0.2452186874943436,0.0007321669909288175,0.2445392912486568,0.24600071925669909,0.24474395900324453,0.2456549585040193,30 +pydtmc,dense-n0500-s01729,dense,500,1729,return/mean-recurrence,0.2500119579999591,0.0031674999991082586,0.2491017602478678,0.3042550727514026,0.24965945800795453,0.25107689600554295,30 +pydtmc,dense-n0500-s01729,dense,500,1729,simulation/10000,0.11817954150319565,0.0003620630013756454,0.11774615624744911,0.1183907912527502,0.11786708300496684,0.11833135449705878,30 +pydtmc,dense-n0500-s01729,dense,500,1729,simulation/100000,1.1796969585047918,0.001772312491084449,1.177116448256129,1.1813097807498707,1.1777901665045647,1.180897083497257,30 +pydtmc,dense-n0500-s01729,dense,500,1729,stationary,0.08896260400797473,0.001647770986892283,0.0881835625077656,0.09079989649762865,0.08883541600516764,0.09061037499486702,30 +pydtmc,dense-n0500-s01729,dense,500,1729,structure/classes-cold,0.04018772900599288,6.218750058906153e-05,0.0400939377504983,0.04022392673869035,0.040159145995858125,0.040214166496298276,30 +pydtmc,dense-n0500-s01729,dense,500,1729,structure/classes-lifecycle,0.36874087499745656,0.001827937492635101,0.3673490312539798,0.37109218775003683,0.3676198960019974,0.3707994999931543,30 +pydtmc,dense-n0500-s01729,dense,500,1729,structure/classes-warm/access,2.156916496460326e-07,6.624497473239978e-10,2.150947755581001e-07,2.1674582530977205e-07,2.152145498257596e-07,2.1610834955936297e-07,30 +pydtmc,dense-n0500-s01729,dense,500,1729,structure/classes-warm/consumed,2.8780879200348862e-05,7.42458003514926e-08,2.8375340650018188e-05,2.8798384425681437e-05,2.8612752050685232e-05,2.8792631249234546e-05,30 +pydtmc,dense-n0500-s01729,dense,500,1729,structure/irreducible-cold,0.04004447899205843,0.00018820800323737785,0.03981516650310368,0.04018831274879631,0.03998129199317191,0.040083125000819564,30 +pydtmc,dense-n0500-s01729,dense,500,1729,structure/irreducible-warm,2.2206045032362454e-07,8.104507287498616e-10,2.216041259089252e-07,2.2525000022142194e-07,2.2173329998622647e-07,2.2364374963217415e-07,30 +pydtmc,dense-n0500-s02718,dense,500,2718,construction/public-consumed,0.3224882080030511,0.0011741875059669837,0.32164401025147527,0.3247808122468996,0.3220174999878509,0.32475952099775895,30 +pydtmc,dense-n0500-s02718,dense,500,2718,evolution/k-10,0.001034479500958696,1.0270501661580056e-05,0.0010207715022261254,0.0010416249897389207,0.0010253544969600625,0.0010384790002717637,30 +pydtmc,dense-n0500-s02718,dense,500,2718,evolution/k-100,0.004129271001147572,1.94790045497939e-05,0.004111927253688918,0.004161291741183959,0.0041230409988202155,0.004141041994444095,30 +pydtmc,dense-n0500-s02718,dense,500,2718,evolution/one-step,0.0007360625022556633,2.8417009161785245e-05,0.0007109889957064297,0.0007677294997847639,0.0007221035048132762,0.0007532504969276488,30 +pydtmc,dense-n0500-s02718,dense,500,2718,hitting-probability/cold-all-states,0.07658535399968969,0.0009601454876246862,0.0757195722508186,0.08002909375500167,0.07579547950444976,0.07834887500212062,30 +pydtmc,dense-n0500-s02718,dense,500,2718,hitting-time/cold-all-states,0.15208295849879505,0.000950041001487989,0.15142026099783834,0.1533624269941356,0.15167368750553578,0.15296912449412048,30 +pydtmc,dense-n0500-s02718,dense,500,2718,power/10,0.1224872284947196,0.0003846045001409948,0.12192437500561937,0.12274328099738341,0.1221964790020138,0.12270156300655799,30 +pydtmc,dense-n0500-s02718,dense,500,2718,power/100,0.12715131250297418,0.0005689375029760413,0.1267274167475989,0.12803735399938887,0.12683687500248197,0.12777893750171643,30 +pydtmc,dense-n0500-s02718,dense,500,2718,power/2,0.12195804149814649,0.0007444170041708276,0.12051246874762,0.12260454100760398,0.1213080000015907,0.12230197899771156,30 +pydtmc,dense-n0500-s02718,dense,500,2718,race/forward-committor,0.2505042705015512,0.0018443749941070564,0.24944164624685072,0.25605373925645836,0.2496209165037726,0.25336920799600193,30 +pydtmc,dense-n0500-s02718,dense,500,2718,return/mean-recurrence,0.25048402050015284,0.000913208001293242,0.249786510506965,0.2521289274955052,0.24996410449966788,0.25159145850193454,30 +pydtmc,dense-n0500-s02718,dense,500,2718,simulation/10000,0.11934797900175909,0.0005459999956656247,0.11889063499984331,0.12021991624715156,0.11904733350093011,0.11973464600305306,30 +pydtmc,dense-n0500-s02718,dense,500,2718,simulation/100000,1.1944247705032467,0.0036911040006089024,1.1840309067520138,1.1971963750002033,1.190998229001707,1.1962724795084796,30 +pydtmc,dense-n0500-s02718,dense,500,2718,stationary,0.08840485399559839,0.001958000000740867,0.08669733325223206,0.09024025999678997,0.08822027050337056,0.08960191650112392,30 +pydtmc,dense-n0500-s02718,dense,500,2718,structure/classes-cold,0.03994412499741884,0.00012529200466815382,0.03987046875045053,0.04022552099195309,0.039897833004943095,0.040191917507763714,30 +pydtmc,dense-n0500-s02718,dense,500,2718,structure/classes-lifecycle,0.3704909160005627,0.0020965209987480193,0.3679924794960243,0.3715303329991002,0.3682239164991188,0.3711577289941488,30 +pydtmc,dense-n0500-s02718,dense,500,2718,structure/classes-warm/access,2.1576459985226393e-07,4.1874955059029003e-10,2.1540619964071083e-07,2.1623542415909468e-07,2.1553535043494777e-07,2.1604790017590858e-07,30 +pydtmc,dense-n0500-s02718,dense,500,2718,structure/classes-warm/consumed,2.8806049999548123e-05,1.849789987318341e-08,2.8781418724611287e-05,2.881760107484297e-05,2.8787552099674938e-05,2.881665625027381e-05,30 +pydtmc,dense-n0500-s02718,dense,500,2718,structure/irreducible-cold,0.03974525000376161,0.00031645850685890764,0.039677781249338295,0.04018259350414155,0.03969535399664892,0.04015562550193863,30 +pydtmc,dense-n0500-s02718,dense,500,2718,structure/irreducible-warm,2.2339994975482113e-07,1.4853998436592493e-09,2.2208855079952626e-07,2.2510520029754845e-07,2.2285000013653188e-07,2.2465830043074675e-07,30 +pydtmc,dense-n0500-s31415,dense,500,31415,construction/public-consumed,0.3238634379886207,0.0037737080056103878,0.32010504199934076,0.3269533435050107,0.3210253124998417,0.32497247812425484,30 +pydtmc,dense-n0500-s31415,dense,500,31415,evolution/k-10,0.0010579165027593262,1.8813007045537233e-05,0.0010444167564855888,0.001079990001016995,0.0010477920004632324,0.0010773960093501955,30 +pydtmc,dense-n0500-s31415,dense,500,31415,evolution/k-100,0.004171312495600432,2.2207997972145677e-05,0.004156114755460294,0.004222719002427766,0.004158729498158209,0.004191499996522907,30 +pydtmc,dense-n0500-s31415,dense,500,31415,evolution/one-step,0.0007411249971482903,2.1812498744111508e-05,0.0007251982497109566,0.0007905205020506401,0.0007280415011337027,0.0007626250007888302,30 +pydtmc,dense-n0500-s31415,dense,500,31415,hitting-probability/cold-all-states,0.0757734789949609,0.00015889600035734475,0.07563932274933904,0.07607201000064379,0.07569016650086269,0.0758052084929659,30 +pydtmc,dense-n0500-s31415,dense,500,31415,hitting-time/cold-all-states,0.1515792295031133,0.0004166255021118559,0.15116009350458626,0.15193739575261134,0.1512408749986207,0.15173816649621585,30 +pydtmc,dense-n0500-s31415,dense,500,31415,power/10,0.12347637499624398,0.0009100624956772663,0.12249932299528155,0.12405624000894022,0.12280860399914673,0.12381008300144458,30 +pydtmc,dense-n0500-s31415,dense,500,31415,power/100,0.12814937499933876,0.0010696245008148253,0.12736370849597733,0.12936791649917723,0.1277105491109978,0.1289782084932085,30 +pydtmc,dense-n0500-s31415,dense,500,31415,power/2,0.12080935399717418,0.0009410829952685162,0.12049457325338153,0.1251549172520754,0.12054000049829483,0.12426433300424833,30 +pydtmc,dense-n0500-s31415,dense,500,31415,race/forward-committor,0.2501700000066194,0.0015692499946453609,0.2483249894976325,0.2515728755024611,0.2494432079984108,0.2514877290086588,30 +pydtmc,dense-n0500-s31415,dense,500,31415,return/mean-recurrence,0.2517992709981627,0.0008462495025014505,0.25104752074184944,0.25304131224402227,0.251217312492372,0.2522400187528547,30 +pydtmc,dense-n0500-s31415,dense,500,31415,simulation/10000,0.118407271009346,0.0002997499977936968,0.11812477149942424,0.11869414624743513,0.11820404200261692,0.1185861651227242,30 +pydtmc,dense-n0500-s31415,dense,500,31415,simulation/100000,1.1857501249978668,0.009861874998023268,1.1778503225032182,1.1988923227436317,1.1809011669975007,1.1962117084985948,30 +pydtmc,dense-n0500-s31415,dense,500,31415,stationary,0.09142104150669184,0.0015524795089731924,0.09008726025058422,0.09305296900492976,0.09105310450104298,0.09236416699422989,30 +pydtmc,dense-n0500-s31415,dense,500,31415,structure/classes-cold,0.04008985399559606,0.00013102150842314586,0.04001847973995609,0.04022470875133877,0.040035916994384024,0.04019768800208112,30 +pydtmc,dense-n0500-s31415,dense,500,31415,structure/classes-lifecycle,0.37362793749343837,0.0028109999984735623,0.3700748852425022,0.3759283750077884,0.3710677704948466,0.3752160840012948,30 +pydtmc,dense-n0500-s31415,dense,500,31415,structure/classes-warm/access,2.162103999580722e-07,6.271002348512419e-10,2.1589269963442348e-07,2.1697287593269722e-07,2.1593120036413895e-07,2.1687290063709953e-07,30 +pydtmc,dense-n0500-s31415,dense,500,31415,structure/classes-warm/consumed,2.8817333299230085e-05,3.4577100450404685e-08,2.8785708275972865e-05,2.887442602477677e-05,2.8794695799297186e-05,2.8844597950228493e-05,30 +pydtmc,dense-n0500-s31415,dense,500,31415,structure/irreducible-cold,0.040337166501558386,0.0004608335002558306,0.039908292004838586,0.04085469799247221,0.04018579200055683,0.04065533349785255,30 +pydtmc,dense-n0500-s31415,dense,500,31415,structure/irreducible-warm,2.227875498647336e-07,9.686991688795169e-10,2.2009585045452696e-07,2.2362605013768189e-07,2.2166249982547016e-07,2.2348120037349873e-07,30 +pydtmc,dense-n1000-s01729,dense,1000,1729,construction/public-consumed,1.341640416503651,0.014377562496520113,1.3253860212535074,1.35058502049651,1.3338753124917275,1.34885427098925,30 +pydtmc,dense-n1000-s01729,dense,1000,1729,evolution/k-10,0.003836125004454516,0.0001501460064901039,0.0037139792475500144,0.004044520759634906,0.003753562501515262,0.003981625006417744,30 +pydtmc,dense-n1000-s01729,dense,1000,1729,evolution/k-100,0.02080793750792509,0.0005144999959156848,0.020316343758167932,0.02129964625419234,0.020488207999733277,0.02114515847988514,30 +pydtmc,dense-n1000-s01729,dense,1000,1729,evolution/one-step,0.0020409789940458722,8.954200166044757e-05,0.001961729005415691,0.002162853750633076,0.0019766250043176115,0.002118208503816277,30 +pydtmc,dense-n1000-s01729,dense,1000,1729,simulation/10000,0.16153345850034384,0.0005441454995889217,0.1611221877465141,0.16217240624973783,0.1611912289954489,0.16188002100534504,30 +pydtmc,dense-n1000-s01729,dense,1000,1729,simulation/100000,1.6080811040010303,0.01437552050629165,1.5942449167414452,1.6231768744983128,1.604229952955393,1.6132251664967043,30 +pydtmc,dense-n1000-s02718,dense,1000,2718,construction/public-consumed,1.3358252710022498,0.014260916497732978,1.3223327497471473,1.3501773022544512,1.3261888749984792,1.3463869165061624,30 +pydtmc,dense-n1000-s02718,dense,1000,2718,evolution/k-10,0.003799812497163657,0.00012933349353261292,0.0036733747547259554,0.003914031243766658,0.0037011455060564913,0.003857333002088126,30 +pydtmc,dense-n1000-s02718,dense,1000,2718,evolution/k-100,0.02114466699276818,0.0004393755007185973,0.02077211450159666,0.02164072950472473,0.020837437499722,0.021564645496255253,30 +pydtmc,dense-n1000-s02718,dense,1000,2718,evolution/one-step,0.0020349795013316907,9.006199979921803e-05,0.0019647599910967983,0.0021934372489340603,0.001983374997507781,0.0021210829945630394,30 +pydtmc,dense-n1000-s02718,dense,1000,2718,simulation/10000,0.16033175000484334,0.001050666491209995,0.1593904062465299,0.16138620824494865,0.15952510399802122,0.16134341699944343,30 +pydtmc,dense-n1000-s02718,dense,1000,2718,simulation/100000,1.5987523544972646,0.007552021503215656,1.5901816664991202,1.6026143849958316,1.5910841250006342,1.6010668960079784,30 +pydtmc,dense-n1000-s31415,dense,1000,31415,construction/public-consumed,1.3280322504942887,0.004985021994798444,1.3231852392527799,1.3344206357542134,1.324998374999268,1.330199353993521,30 +pydtmc,dense-n1000-s31415,dense,1000,31415,evolution/k-10,0.003616083507949952,0.00010604200360830873,0.0035112809964630287,0.0037210730006336235,0.00354614599928027,0.0036981250013923272,30 +pydtmc,dense-n1000-s31415,dense,1000,31415,evolution/k-100,0.020661437505623326,0.00028249949536984786,0.02035464599248371,0.020847354495344916,0.020424416499736253,0.02077491700038081,30 +pydtmc,dense-n1000-s31415,dense,1000,31415,evolution/one-step,0.0020591660068021156,0.00015187450480880216,0.001957718744961312,0.002388968499872135,0.0020100210022064857,0.0022844159975647926,30 +pydtmc,dense-n1000-s31415,dense,1000,31415,simulation/10000,0.16052133300399873,0.0012745214989990927,0.15953349975825404,0.16188513550150674,0.15977789550379384,0.16165408350207144,30 +pydtmc,dense-n1000-s31415,dense,1000,31415,simulation/100000,1.5868686670000898,0.012490208500821609,1.5771919894978055,1.6103151457427884,1.5784743545009405,1.6024401250033407,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,construction/public-consumed,0.0003589370026020333,3.1244999263435602e-06,0.0003561142584658228,0.00036243725116946734,0.000357521501427982,0.0003612368269386934,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,evolution/k-10,5.1041490223724395e-05,5.619876901619136e-07,5.066625089966692e-05,5.2072497055632994e-05,5.07079967064783e-05,5.17504959134385e-05,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,evolution/k-100,0.00025962499785237014,1.5005061868578196e-06,0.00025757299590623006,0.00026105275173904374,0.00025881299370666966,0.00026064550183946267,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,evolution/one-step,2.9708498914260417e-05,4.169924068264663e-07,2.9416743927868083e-05,3.082249531871639e-05,2.96039943350479e-05,3.0166993383318186e-05,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,finite-time/n-step/k-10,4.983300459571183e-05,7.494963938370347e-07,4.924999666400254e-05,5.106200114823878e-05,4.947845209244406e-05,5.045800207881257e-05,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,finite-time/n-step/k-100,0.0002609375005704351,1.0625008144415915e-06,0.0002601457526907325,0.0002622394931677263,0.00026037499628728256,0.00026179150154348463,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,finite-time/observation/k-10,5.014600174035877e-05,7.285052561201155e-07,4.959350189892575e-05,5.110425627208315e-05,4.968749999534339e-05,5.081300332676619e-05,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,finite-time/observation/k-100,0.00025812450621742755,1.0420044418424368e-06,0.0002571772456576582,0.00025913575154845603,0.0002576039987616241,0.00025877050211420283,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,finite-time/step,8.749993867240846e-07,4.200410330668092e-08,8.329952834174037e-07,9.170034900307655e-07,8.334973244927824e-07,9.169962140731514e-07,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,hitting-probability/cold-all-states,4.381299368105829e-05,9.379873517900705e-07,4.3291758629493415e-05,4.636499943444505e-05,4.350000381236896e-05,4.5374996261671185e-05,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,hitting-time/cold-all-states,9.227100235875696e-05,1.8749924493022263e-06,9.156250962405466e-05,9.580149708199315e-05,9.181250061374158e-05,9.416700049769133e-05,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,hitting/bounded/at-most/k-10,4.36670015915297e-05,5.004985723644495e-07,4.317750426707789e-05,4.426049781613983e-05,4.3333500798325986e-05,4.4083491957280785e-05,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,hitting/bounded/at-most/k-100,0.0003391664940863848,2.2089952835813165e-06,0.0003373437539266888,0.00034154225068050437,0.00033799999073380604,0.00034079199394909665,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,hitting/bounded/exact/k-10,4.2437495721969754e-05,5.004985723644495e-07,4.20732467318885e-05,4.3114992877235636e-05,4.220849950797856e-05,4.272901933290996e-05,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,hitting/bounded/exact/k-100,0.0003332505075377412,2.3329921532422304e-06,0.0003297397452115547,0.00033504199018352665,0.0003320419928058982,0.00033445800363551825,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,hitting/bounded/greater-than/k-10,4.3353989894967526e-05,5.205001798458397e-07,4.296849510865286e-05,4.398950113682076e-05,4.306250048102811e-05,4.3770502088591456e-05,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,hitting/bounded/greater-than/k-100,0.00033868750324472785,4.146000719629228e-06,0.00033404124769731425,0.0003423749913054053,0.00033506250474601984,0.0003410210047150031,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,power/10,0.000317812999128364,2.2294989321380854e-06,0.00031610399310011417,0.00032063574326457456,0.00031654150370741263,0.00031958350155036896,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,power/100,0.0003204580061719753,1.8954960978589952e-06,0.00031902074988465756,0.0003228332498110831,0.00031937449966790155,0.0003217295015929267,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,power/2,0.0003080419992329553,1.6664998838678002e-06,0.00030653175053885207,0.0003099270033999346,0.0003070004968321882,0.0003091675431278418,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,race/forward-committor,0.000229124998440966,3.521003236528486e-06,0.00022588549836655147,0.00023231275554280728,0.00022668799647362903,0.0002306454989593476,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,return/bounded/k-10,4.3208499846514314e-05,4.5899651013314724e-07,4.280149732949212e-05,4.381249891594052e-05,4.287500632926822e-05,4.354149859864265e-05,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,return/bounded/k-100,0.0003365419979672879,5.896501534152776e-06,0.0003311772488814313,0.00035530274544726126,0.00033347849966958165,0.00034583350497996435,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,return/mean-recurrence,0.0002579374995548278,2.6039997464977205e-06,0.0002561247492849361,0.00026107349185622297,0.0002571244986029342,0.0002598965002107434,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,simulation/10000,0.0778914580005221,0.0005647915022564121,0.07732193725314573,0.07842898925082409,0.07755058300244855,0.07822262499394128,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,simulation/100000,0.779284103991813,0.0015496670093853027,0.7697285412468773,0.780243853747379,0.7752818749941071,0.7798787295032525,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,stationary,7.90210033301264e-05,9.164941729977727e-07,7.815625940565951e-05,7.994774932740256e-05,7.83540090196766e-05,7.96670065028593e-05,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,structure/classes-cold,2.3395507014356554e-05,6.870104698464274e-07,2.2708249161951244e-05,2.4021002900553867e-05,2.2750005882699043e-05,2.3833505110815167e-05,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,structure/classes-lifecycle,0.0004147084982832894,2.6874986360780895e-06,0.0004125835075683426,0.00041746899296413176,0.0004130000015720725,0.0004164165002293885,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,structure/classes-warm/access,2.1633959986502305e-07,4.603993147611592e-10,2.160593754524598e-07,2.1978125005261973e-07,2.161437994800508e-07,2.1840420085936785e-07,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,structure/classes-warm/consumed,9.362561999296304e-07,4.3833497329615006e-09,9.265562242944725e-07,9.395948000019416e-07,9.305755044624675e-07,9.389710612958879e-07,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,structure/irreducible-cold,2.2604494006372988e-05,4.1649764170870185e-07,2.226050855824724e-05,2.3156499082688242e-05,2.2333500965032727e-05,2.3041997337713838e-05,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,structure/irreducible-warm,2.2487710011773742e-07,2.514549851184704e-09,2.2287495012278668e-07,2.2805414992035365e-07,2.2380829905159771e-07,2.2726460083504208e-07,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,visits/bounded-expectation/k-10,1.9625003915280104e-05,3.1249510357156396e-07,1.9427250663284212e-05,2.0030747691635042e-05,1.9499995505611875e-05,1.9937491742894053e-05,30 +pydtmc,low-outdegree-n0010-s01729,low-outdegree,10,1729,visits/bounded-expectation/k-100,7.962549716467038e-05,7.499984349124134e-07,7.909349733381532e-05,8.04484952823259e-05,7.925000645627733e-05,8.010399324120954e-05,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,construction/public-consumed,0.0003568545071175322,2.8959984774701297e-06,0.0003539790050126612,0.0003596562528400682,0.00035433349694358185,0.0003582920035114512,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,evolution/k-10,5.112550570629537e-05,4.584944690577686e-07,5.076050729257986e-05,5.21042529726401e-05,5.0812501285690814e-05,5.137499829288572e-05,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,evolution/k-100,0.0002597505081212148,2.0005099941045046e-06,0.00025837474095169455,0.0002748024962784257,0.00025906198297889207,0.00026616700051818043,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,evolution/one-step,3.006200131494552e-05,7.080016075633466e-07,2.962474900414236e-05,3.14170029014349e-05,2.983299782499671e-05,3.0958501156419516e-05,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,finite-time/n-step/k-10,4.9875001423060894e-05,4.5850174501538277e-07,4.9479742301627994e-05,5.10835052409675e-05,4.962499224347994e-05,5.0520502554718405e-05,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,finite-time/n-step/k-100,0.00026331299886805937,3.6040000850334764e-06,0.00025697874662000686,0.00026582300051813945,0.00026027100102510303,0.0002650420065037906,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,finite-time/observation/k-10,4.989550507161766e-05,6.665068212896585e-07,4.9448255595052615e-05,5.093724757898599e-05,4.96045031468384e-05,5.033349589211866e-05,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,finite-time/observation/k-100,0.0002587919952929951,1.9584986148402095e-06,0.0002577505038061645,0.0002609682524052914,0.0002579789943411015,0.00026045850245282054,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,finite-time/step,8.750066626816988e-07,4.100729711353779e-08,8.442584658041596e-07,9.485011105425656e-07,8.749921107664704e-07,9.170034900307655e-07,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,hitting-probability/cold-all-states,4.383350460557267e-05,8.545102900825441e-07,4.303124296711758e-05,4.597924998961389e-05,4.329199146013707e-05,4.464600351639092e-05,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,hitting-time/cold-all-states,9.189599950332195e-05,1.6255071386694908e-06,9.071849854080938e-05,9.654149835114367e-05,9.120848899328849e-05,9.445800969842821e-05,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,hitting/bounded/at-most/k-10,4.302100569475442e-05,2.9200600693002343e-07,4.283325688447803e-05,4.365575296105817e-05,4.291649383958429e-05,4.32920060120523e-05,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,hitting/bounded/at-most/k-100,0.0003353534993948415,1.042011717800051e-06,0.00033277124748565257,0.0003360307528055273,0.0003342079871799797,0.00033577099402464227,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,hitting/bounded/exact/k-10,4.20005017076619e-05,6.875052349641919e-07,4.134349728701636e-05,4.266650648787618e-05,4.150000313529745e-05,4.2437495721969754e-05,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,hitting/bounded/exact/k-100,0.0003313330016680993,1.8334976630285382e-06,0.00033026024902937934,0.00034155224784626625,0.0003303749981569126,0.0003368754987604916,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,hitting/bounded/greater-than/k-10,4.341650492278859e-05,4.3800537241622806e-07,4.305225229472853e-05,4.40419971710071e-05,4.310450458433479e-05,4.393800190882757e-05,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,hitting/bounded/greater-than/k-100,0.00033897950197570026,5.542002327274531e-06,0.0003361767521710135,0.0003450834919931367,0.0003366250020917505,0.0003443335008341819,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,power/10,0.00031879149901214987,1.7920028767548501e-06,0.0003172184915456455,0.0003222704981453717,0.0003175000019837171,0.0003215409960830584,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,power/100,0.0003230834990972653,2.124994352925569e-06,0.0003215627511963248,0.00032609374829917215,0.0003218334968551062,0.0003247505010222085,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,power/2,0.00030941650038585067,2.1040032152086496e-06,0.0003082605035160668,0.00031236475115292706,0.0003084164927713573,0.0003119999964837916,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,race/forward-committor,0.00023225000040838495,2.792003215290606e-06,0.00022992649610387161,0.00023577100728289224,0.00023008350399322808,0.00023435450566466898,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,return/bounded/k-10,4.320850712247193e-05,5.625042831525207e-07,4.280250141164288e-05,4.381299368105829e-05,4.2917003156617284e-05,4.343749606050551e-05,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,return/bounded/k-100,0.00033791699388530105,3.062486939597875e-06,0.0003344589968037326,0.0003390517449588515,0.00033506250474601984,0.0003387710021343082,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,return/mean-recurrence,0.00026124999567400664,3.541994374245405e-06,0.00025709375404403545,0.0002641772516653873,0.00025797535163292197,0.0002626249988679774,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,simulation/10000,0.07832035400497261,0.00045339599455473945,0.07710107300590607,0.07866621875291457,0.07760289600264514,0.0785419999883743,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,simulation/100000,0.7784111460059648,0.012823687495256308,0.7594537814984506,0.7899230939983681,0.7630936250061495,0.7860937709920108,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,stationary,7.881199417170137e-05,1.1880038073286414e-06,7.736500265309587e-05,7.994774932740256e-05,7.777100836392492e-05,7.98124965513125e-05,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,structure/classes-cold,2.3312495613936335e-05,6.039917934685946e-07,2.2823245672043413e-05,2.403150574536994e-05,2.295849844813347e-05,2.3833497834857553e-05,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,structure/classes-lifecycle,0.00042029099859064445,6.479000148829073e-06,0.0004148125008214265,0.0004358025071269367,0.0004155404634730075,0.0004265000025043264,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,structure/classes-warm/access,2.1663750012521632e-07,3.9169972296804584e-10,2.1631877571053337e-07,2.1745725025539287e-07,2.1634580043610186e-07,2.1700415018131025e-07,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,structure/classes-warm/consumed,9.321833007561509e-07,2.8833492251578303e-09,9.27006250640261e-07,9.342010755062801e-07,9.283958002924919e-07,9.337020499515348e-07,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,structure/irreducible-cold,2.310400304850191e-05,5.420079105533659e-07,2.2374759282683954e-05,2.3489501472795382e-05,2.2561995137948543e-05,2.3396001779474318e-05,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,structure/irreducible-warm,2.2356459958245978e-07,8.104492735583359e-10,2.228187004220672e-07,2.2446145085268655e-07,2.2323960001813247e-07,2.2414164996007457e-07,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,visits/bounded-expectation/k-10,1.977050123969093e-05,3.1249510357156396e-07,1.9500002963468432e-05,2.015650170505978e-05,1.958400389412418e-05,1.997900108108297e-05,30 +pydtmc,low-outdegree-n0010-s02718,low-outdegree,10,2718,visits/bounded-expectation/k-100,7.843700586818159e-05,8.95997800398618e-07,7.789574738126248e-05,7.962500603753142e-05,7.812550029484555e-05,7.947952799440826e-05,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,construction/public-consumed,0.000357083001290448,1.145504938904196e-06,0.0003564889993867837,0.0003603649929573294,0.00035675049730343744,0.0003590409905882552,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,evolution/k-10,5.13540071551688e-05,7.500129868276417e-07,5.059349496150389e-05,5.2041999879293144e-05,5.077050445834175e-05,5.1875002100132406e-05,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,evolution/k-100,0.0002599790022941306,1.2085001799277961e-06,0.00025909349642461166,0.0002613334982015658,0.0002591874945210293,0.00026106250152224675,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,evolution/one-step,2.9978997190482914e-05,9.585055522620678e-07,2.937500539701432e-05,3.132349957013503e-05,2.954150113509968e-05,3.093750274274498e-05,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,finite-time/n-step/k-10,5.004149716114625e-05,5.830006557516754e-07,4.955175245413557e-05,5.10417485202197e-05,4.96045031468384e-05,5.049999163020402e-05,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,finite-time/n-step/k-100,0.00025564600218785927,1.4375036698766053e-06,0.0002544272501836531,0.0002622297470225021,0.00025456250295974314,0.0002587919952929951,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,finite-time/observation/k-10,4.9583002692088485e-05,8.95997800398618e-07,4.9124999350169674e-05,5.0739497964968905e-05,4.9166003009304404e-05,5.03330011270009e-05,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,finite-time/observation/k-100,0.000263770496530924,3.083507181145251e-06,0.00025768749765120447,0.0002658855009940453,0.00026033350150100887,0.0002652089897310361,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,finite-time/step,8.750066626816988e-07,6.250047590583563e-08,8.329989213962108e-07,9.477480489294976e-07,8.335046004503965e-07,9.170034900307655e-07,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,hitting-probability/cold-all-states,4.385449574328959e-05,8.749921107664704e-07,4.310475196689367e-05,4.6291257604025304e-05,4.333299875725061e-05,4.483399970922619e-05,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,hitting-time/cold-all-states,9.149950346909463e-05,1.978994987439364e-06,9.041624798555858e-05,9.599999248166569e-05,9.058299474418163e-05,9.445800969842821e-05,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,hitting/bounded/at-most/k-10,4.3249994632788e-05,4.79492882732302e-07,4.2812749597942457e-05,4.3874504626728594e-05,4.289549542590976e-05,4.3562991777434945e-05,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,hitting/bounded/at-most/k-100,0.0003340210023452528,2.5000044843181968e-06,0.00033225000152015127,0.0003383745061000809,0.0003323339915368706,0.0003378959954716265,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,hitting/bounded/exact/k-10,4.266699397703633e-05,6.459958967752755e-07,4.189574610791169e-05,4.320849620853551e-05,4.2041996493935585e-05,4.302099841879681e-05,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,hitting/bounded/exact/k-100,0.0003304999991087243,4.728994099423289e-06,0.0003278230033174623,0.0003371042475919239,0.00032960450334940106,0.0003366245000506751,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,hitting/bounded/greater-than/k-10,4.3396008550189435e-05,5.625042831525207e-07,4.283325688447803e-05,4.390649701235816e-05,4.295799590181559e-05,4.377049481263384e-05,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,hitting/bounded/greater-than/k-100,0.00033839550451375544,2.9380025807768106e-06,0.0003342497511766851,0.00034066625448758714,0.0003354165019118227,0.00034016753907053495,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,power/10,0.0003163959991070442,1.7295024008490145e-06,0.0003148852483718656,0.00031849025253904983,0.00031500049954047427,0.00031768799817655236,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,power/100,0.0003210835056961514,2.124485035892576e-06,0.0003200109968020115,0.0003239164980186615,0.00032039549842011184,0.00032329149689758196,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,power/2,0.00032768699747975916,6.6465072450228035e-06,0.0003100422545685433,0.00033115625410573557,0.0003181669962941669,0.00032958299561869353,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,race/forward-committor,0.00023247900389833376,6.103997293394059e-06,0.00022695824736729264,0.00023905174020910636,0.00022833349066786468,0.00023691650130786002,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,return/bounded/k-10,4.3520500184968114e-05,3.954919520765543e-07,4.3031246605096385e-05,4.382350743981078e-05,4.3145504605490714e-05,4.374999844003469e-05,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,return/bounded/k-100,0.00033822949626483023,1.7080019460991025e-06,0.00033296874971711077,0.0003393749939277768,0.0003349995022290386,0.0003390630237845471,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,return/mean-recurrence,0.00026106249424628913,3.729495801962912e-06,0.0002570627511886414,0.00026374974549980834,0.00025729048902576327,0.00026295850693713874,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,simulation/10000,0.07765316649602028,0.0012917294952785596,0.07656253074674169,0.07952785425368347,0.07690641649242025,0.07877383349114098,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,simulation/100000,0.7738390829981654,0.00406474949704716,0.7714924164974946,0.7978214475078858,0.7728076249914011,0.794158395510749,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,stationary,7.993749750312418e-05,1.2080054148100317e-06,7.874999209889211e-05,8.116650860756636e-05,7.89795012678951e-05,8.06460011517629e-05,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,structure/classes-cold,2.3687505745328963e-05,4.1650491766631603e-07,2.338550257263705e-05,2.468700404278934e-05,2.3500004317611456e-05,2.4041997858148537e-05,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,structure/classes-lifecycle,0.0004166670041740872,3.021006705239415e-06,0.00041357299414812587,0.00041920875082723796,0.0004144999911659397,0.00041831250564428046,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,structure/classes-warm/access,2.211353501479607e-07,4.412449925439413e-09,2.1737497481808532e-07,2.486291501554661e-07,2.1764584962511436e-07,2.3315209982683882e-07,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,structure/classes-warm/consumed,9.447896001802291e-07,7.197949889814447e-09,9.374603752803523e-07,9.515604007901857e-07,9.401062503457069e-07,9.477666491875425e-07,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,structure/irreducible-cold,2.2999993234407157e-05,6.665068212896585e-07,2.2468499082606286e-05,2.368724744883366e-05,2.2603999241255224e-05,2.3582993890158832e-05,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,structure/irreducible-warm,2.252916994621046e-07,4.5830092858523264e-10,2.2481874984805472e-07,2.2569270004169086e-07,2.2512294963235035e-07,2.2554379975190385e-07,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,visits/bounded-expectation/k-10,1.9603998225647956e-05,2.915039658546448e-07,1.929124482558109e-05,1.9822757167275995e-05,1.933349994942546e-05,1.9750004867091775e-05,30 +pydtmc,low-outdegree-n0010-s31415,low-outdegree,10,31415,visits/bounded-expectation/k-100,7.816699508111924e-05,4.789981176145375e-07,7.76249980845023e-05,7.847925007808954e-05,7.781250315019861e-05,7.83125069574453e-05,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,construction/public-consumed,0.000840083506773226,2.478482201695442e-06,0.0008388014939555433,0.0008451559988316149,0.0008388960050069727,0.0008425619889749214,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,evolution/k-10,6.42709928797558e-05,6.459958967752755e-07,6.408300032489933e-05,6.574949657078832e-05,6.410400237655267e-05,6.522950570797548e-05,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,evolution/k-100,0.00028022899641655385,2.103493898175657e-06,0.00027723974926630035,0.00028182274400023744,0.0002781255025183782,0.00028139599453425035,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,evolution/one-step,4.2895997466985136e-05,9.165014489553869e-07,4.2198247683700174e-05,4.401074693305418e-05,4.237499524606392e-05,4.368749796412885e-05,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,finite-time/n-step/k-10,6.343749555526301e-05,5.414985935203731e-07,6.260425652726553e-05,6.390650014509447e-05,6.302049587247893e-05,6.36670010862872e-05,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,finite-time/n-step/k-100,0.0002780205031740479,2.5830086087808013e-06,0.0002761770047072787,0.00028090649720979854,0.00027683300140779465,0.0002790093749354128,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,finite-time/observation/k-10,6.352099444484338e-05,8.74497345648706e-07,6.295900675468147e-05,6.501100506284274e-05,6.312450568657368e-05,6.42910017631948e-05,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,finite-time/observation/k-100,0.00027958350256085396,2.1255036699585617e-06,0.0002775310022116173,0.0002817495114868507,0.0002781250004773028,0.0002812089951476082,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,finite-time/step,1.1875017662532628e-06,6.250775186344981e-08,1.1352567526046187e-06,1.2814962246920913e-06,1.1669908417388797e-06,1.2499949662014842e-06,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,hitting-probability/cold-all-states,7.195850048447028e-05,1.5205005183815956e-06,7.068800550769083e-05,7.362525502685457e-05,7.135450141504407e-05,7.31664986233227e-05,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,hitting-time/cold-all-states,0.0001487085028202273,2.1880041458643973e-06,0.0001471877476433292,0.00015197899483609945,0.00014733349962625653,0.0001504379979451187,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,hitting/bounded/at-most/k-10,5.9333498938940465e-05,5.209949449636042e-07,5.8802255807677284e-05,5.980174682918005e-05,5.8833000366576016e-05,5.954149673925713e-05,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,hitting/bounded/at-most/k-100,0.000509666497237049,5.499503458850086e-06,0.0005063232565589715,0.0005233647498243954,0.000507271004607901,0.0005169584983377717,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,hitting/bounded/exact/k-10,6.129150278866291e-05,1.7085039871744812e-06,5.8698005886981264e-05,6.254125037230551e-05,5.9625497669912875e-05,6.220799696166068e-05,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,hitting/bounded/exact/k-100,0.0004987704960512929,3.4165059332735837e-06,0.0004953335010213777,0.0005019167547288816,0.0004965624975739047,0.0005002300180422026,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,hitting/bounded/greater-than/k-10,6.10630086157471e-05,2.0220031728968024e-06,5.958274414297193e-05,6.399975973181427e-05,6.029149517416954e-05,6.331249460345134e-05,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,hitting/bounded/greater-than/k-100,0.0005183960020076483,6.833499355707318e-06,0.0005126039977767505,0.0005249169953458477,0.000516583510034252,0.0005203124892432243,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,power/10,0.000562146000447683,2.687003870960325e-06,0.0005576355069933925,0.0005643332406179979,0.0005604999896604568,0.0005639789960696362,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,power/100,0.0005610619991784915,3.3535034162923694e-06,0.0005575417453655973,0.0005633542459690943,0.0005589164939010516,0.0005625414996757172,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,power/2,0.00043004149483749643,2.458487870171666e-06,0.00042805275370483287,0.0004332187454565428,0.000428999999712687,0.00043256249773548916,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,race/forward-committor,0.0005722709975088947,8.082999556791037e-06,0.0005678120069205761,0.0005896562579437159,0.0005691250044037588,0.0005867085055797361,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,return/bounded/k-10,5.9999991208314896e-05,1.229003828484565e-06,5.918774695601314e-05,6.184374433360063e-05,5.9354002587497234e-05,6.125000072643161e-05,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,return/bounded/k-100,0.0005141250003362074,7.166505383793265e-06,0.0005078860049252398,0.0005436770006781444,0.0005088539983262308,0.000530833494849503,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,return/mean-recurrence,0.0006836460015620105,5.250003596302122e-06,0.0006797292444389313,0.0006907395036250819,0.0006809379992773756,0.0006897510307680932,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,simulation/10000,0.07997849949606461,0.0022298745025182143,0.0778093440021621,0.08410141675267369,0.0788787709971075,0.08016691599914338,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,simulation/100000,0.7894397085037781,0.0012072289973730221,0.7884216457532602,0.7905924789956771,0.7891297083235258,0.790375728996878,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,stationary,0.00018672949954634532,1.0625008144415915e-06,0.0001857502466009464,0.0001877292488643434,0.00018612499115988612,0.0001871249987743795,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,structure/classes-cold,5.137499829288572e-05,1.0000003385357559e-06,5.037500523030758e-05,5.239600068307482e-05,5.07079967064783e-05,5.2207993576303124e-05,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,structure/classes-lifecycle,0.0009255000040866435,4.354500561021268e-06,0.0009219482490152586,0.0009301145000790711,0.0009235004981746897,0.0009276250057155266,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,structure/classes-warm/access,2.1791670005768535e-07,1.0312498488928937e-09,2.1729584950662684e-07,2.3864060058258474e-07,2.1746670026914217e-07,2.2836455027572813e-07,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,structure/classes-warm/consumed,1.7277708000619896e-06,2.070800110232135e-09,1.7205885247676634e-06,1.7295885245403043e-06,1.7257979496207554e-06,1.7293979006353765e-06,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,structure/irreducible-cold,4.877049650531262e-05,4.579997039400041e-07,4.8457994125783443e-05,4.964624531567097e-05,4.8499998229090124e-05,4.927050031255931e-05,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,structure/irreducible-warm,2.2437289953813888e-07,1.2187003449071206e-09,2.2337082591548096e-07,2.2616147543885747e-07,2.2354789907694793e-07,2.2586254999623634e-07,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,visits/bounded-expectation/k-10,3.1562500225845724e-05,3.125096554867923e-07,3.130225377390161e-05,3.2124753488460556e-05,3.135450242552906e-05,3.179200575686991e-05,30 +pydtmc,low-outdegree-n0025-s01729,low-outdegree,25,1729,visits/bounded-expectation/k-100,9.537499863654375e-05,7.709968485869467e-07,9.457325359107926e-05,9.612498979549855e-05,9.493700781604275e-05,9.585399675415829e-05,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,construction/public-consumed,0.0008413750038016587,4.146007995586842e-06,0.0008365722496819217,0.0008436147436441388,0.0008375809324206784,0.0008426660060649738,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,evolution/k-10,6.591700366698205e-05,1.2290111044421792e-06,6.47707493044436e-05,6.719750672345981e-05,6.495900015579537e-05,6.697900244034827e-05,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,evolution/k-100,0.0002842289977706969,4.166497092228383e-06,0.0002810834994306788,0.00029133374846423976,0.00028193750040372834,0.0002861875036614947,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,evolution/one-step,4.445850208867341e-05,1.082989911083132e-06,4.379199890536256e-05,4.560374145512469e-05,4.3937499867752194e-05,4.5084001612849534e-05,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,finite-time/n-step/k-10,6.368749745888636e-05,8.750066626816988e-07,6.317724546534009e-05,6.505200508399867e-05,6.322900298982859e-05,6.447900523198768e-05,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,finite-time/n-step/k-100,0.0002873955018003471,3.5625052987597883e-06,0.0002853544974641409,0.0002916564953920897,0.000285854002868291,0.0002905840239691315,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,finite-time/observation/k-10,6.570850382559001e-05,1.6255071386694908e-06,6.366600064211525e-05,6.66462437948212e-05,6.385299311659764e-05,6.629149720538408e-05,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,finite-time/observation/k-100,0.00027800000680144876,3.04150307783857e-06,0.0002752502477960661,0.0002814272556861397,0.00027558350120671093,0.0002808125063893385,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,finite-time/step,1.2499949662014842e-06,4.1996827349066734e-08,1.2079981388524175e-06,1.291991793550551e-06,1.2085001799277961e-06,1.2914970284327865e-06,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,hitting-probability/cold-all-states,7.545800326624885e-05,1.8964929040521383e-06,7.433350765495561e-05,7.740674118394963e-05,7.460399501724169e-05,7.697900582570583e-05,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,hitting-time/cold-all-states,0.00014970850315876305,2.7080022846348584e-06,0.00014767650645808317,0.0001535832416266203,0.00014799999917158857,0.0001527084968984127,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,hitting/bounded/at-most/k-10,6.14789969404228e-05,1.8119972082786262e-06,5.968775076325983e-05,6.357274833135307e-05,6.020799628458917e-05,6.250049773370847e-05,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,hitting/bounded/at-most/k-100,0.0005238544981693849,9.166506060864776e-06,0.0005190937554289121,0.0005379172507673502,0.0005202495012781583,0.0005337914990377612,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,hitting/bounded/exact/k-10,5.8667006669566035e-05,9.165014489553869e-07,5.8145757066085935e-05,5.9749498177552596e-05,5.8250006986781955e-05,5.9542013332247734e-05,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,hitting/bounded/exact/k-100,0.0005052499982411973,1.0875002772081643e-05,0.0004999480079277419,0.0005773227385361679,0.0005007079889765009,0.0005746722223193501,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,hitting/bounded/greater-than/k-10,6.093749834690243e-05,1.4789984561502934e-06,5.9791753301396966e-05,6.702050450257957e-05,5.993750528432429e-05,6.464550097007304e-05,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,hitting/bounded/greater-than/k-100,0.0005070624974905513,1.0978998034261167e-05,0.0004959582474839408,0.0005139065033290535,0.0004982504906365648,0.000511187499796506,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,power/10,0.0005611040032817982,1.1687501682899892e-05,0.000553437253984157,0.0005820942496939097,0.0005576249968726188,0.0005806874978588894,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,power/100,0.0005715625011362135,1.3666496670339257e-05,0.0005637079957523383,0.0006045105074008461,0.0005646664940286428,0.0005919170071138069,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,power/2,0.0004367080036900006,3.4580007195472717e-06,0.0004333440047048498,0.00044057299601263367,0.00043454149999888614,0.0004392495029605925,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,race/forward-committor,0.0005787710033473559,1.412499841535464e-05,0.0005632602478726767,0.0005908544990234077,0.0005652914987877011,0.0005900205069337972,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,return/bounded/k-10,6.0520505940075964e-05,1.0205039870925248e-06,5.9676494856830686e-05,6.754150308552198e-05,5.991698708385229e-05,6.397950346581638e-05,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,return/bounded/k-100,0.0005698544991901144,6.74949842505157e-06,0.0005073645079392008,0.0005760102467320394,0.0005376875051297247,0.000573562501813285,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,return/mean-recurrence,0.0007002915081102401,1.5083503967616707e-05,0.0006883750029373914,0.0009262392559321597,0.0006891459997859783,0.0007872820884585947,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,simulation/10000,0.07868081199558219,0.0014090834956732579,0.0772308124905976,0.08005810399117763,0.07841860449843807,0.07985385449865134,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,simulation/100000,0.7932471460007946,0.004138229000091087,0.7904911980040197,0.8008443329963484,0.7912922982526651,0.7984605000019656,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,stationary,0.0001885210003820248,5.416506610345095e-06,0.00018369799727224745,0.00019577025159378536,0.00018635450396686792,0.00019049999536946416,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,structure/classes-cold,5.162500747246668e-05,1.0210133041255176e-06,5.0666494644246995e-05,5.2718747610924765e-05,5.079199036117643e-05,5.212500400375575e-05,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,structure/classes-lifecycle,0.0009278124998672865,4.000008630100638e-06,0.0009243437452823855,0.0009321562611148693,0.0009257915007765405,0.0009307710060966201,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,structure/classes-warm/access,2.1952294919174163e-07,2.8791488148271827e-09,2.1829479919688312e-07,2.288260995555902e-07,2.190167004300747e-07,2.2813534960732796e-07,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,structure/classes-warm/consumed,1.7436853995604906e-06,2.6945800345856706e-08,1.7220396002812777e-06,1.803290624229703e-06,1.7240541499631944e-06,1.783712499309331e-06,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,structure/irreducible-cold,4.956200427841395e-05,2.020009560510516e-06,4.7895751777105033e-05,5.2917002903996035e-05,4.808350058738142e-05,5.2167000831104815e-05,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,structure/irreducible-warm,2.264875001856126e-07,1.3396005670074438e-09,2.257000254758168e-07,2.3346875022980383e-07,2.2609584921156058e-07,2.2997289925115183e-07,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,visits/bounded-expectation/k-10,3.2125004508998245e-05,4.5850174501538277e-07,3.162499706377275e-05,3.244774052291177e-05,3.170799755025655e-05,3.239550278522074e-05,30 +pydtmc,low-outdegree-n0025-s02718,low-outdegree,25,2718,visits/bounded-expectation/k-100,9.70625042100437e-05,1.8750070012174547e-06,9.549999958835542e-05,0.00010071874567074701,9.581249469192699e-05,0.000100271005067043,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,construction/public-consumed,0.0008442295002168976,4.750007065013051e-06,0.0008397812416660599,0.0008539060036127921,0.000840979497297667,0.0008468750020256266,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,evolution/k-10,6.472949462477118e-05,3.9600126910954714e-07,6.441600271500647e-05,6.587500320165418e-05,6.44999963697046e-05,6.508349906653166e-05,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,evolution/k-100,0.0002833960097632371,4.499997885432094e-06,0.00027765599588747136,0.0002869895033654757,0.00028089650004403666,0.0002859170053852722,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,evolution/one-step,4.452050052350387e-05,1.2289965525269508e-06,4.324975088820793e-05,4.537475251709111e-05,4.381249891594052e-05,4.487500700633973e-05,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,finite-time/n-step/k-10,6.289549492066726e-05,6.460031727328897e-07,6.245826079975814e-05,6.381249113474041e-05,6.256250344449654e-05,6.354200013447553e-05,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,finite-time/n-step/k-100,0.0002785830001812428,1.6870035324245691e-06,0.00027599975874181837,0.00027940574727836065,0.00027689599664881825,0.0002792289960780181,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,finite-time/observation/k-10,6.356249650707468e-05,9.379946277476847e-07,6.282250615186058e-05,6.470849984907545e-05,6.302099791355431e-05,6.437449337681755e-05,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,finite-time/observation/k-100,0.0002823329996317625,4.895497113466263e-06,0.0002786667464533821,0.00030593774863518775,0.0002801249938784167,0.0002922363075413159,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,finite-time/step,1.2090022210031748e-06,4.300090949982405e-08,1.1669944797176868e-06,1.2917444109916687e-06,1.167005393654108e-06,1.270498614758253e-06,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,hitting-probability/cold-all-states,7.454200385836884e-05,2.2294989321380854e-06,7.24892488506157e-05,7.676050154259428e-05,7.277099939528853e-05,7.585399725940078e-05,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,hitting-time/cold-all-states,0.00015110400272533298,3.875000402331352e-06,0.00014733325224369764,0.00015490623991354369,0.00014756200835108757,0.00015304150292649865,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,hitting/bounded/at-most/k-10,5.9521509683690965e-05,1.1465090210549533e-06,5.8614994486561045e-05,6.155149458209053e-05,5.893750494578853e-05,6.081249739509076e-05,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,hitting/bounded/at-most/k-100,0.0005116875036037527,3.7709978641942143e-06,0.0005089787482575048,0.0005560829995374661,0.0005096250024507754,0.0005315835005603731,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,hitting/bounded/exact/k-10,6.11455034231767e-05,2.0205043256282806e-06,5.9718502598116174e-05,6.637500700890087e-05,6.004150054650381e-05,6.493750697700307e-05,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,hitting/bounded/exact/k-100,0.0005094169973745011,1.3395503628998995e-05,0.0004923644919472281,0.0005148332456883509,0.0005013964982936159,0.0005103986064568743,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,hitting/bounded/greater-than/k-10,6.45414984319359e-05,3.895998816005886e-06,6.064599801902659e-05,6.838499393779784e-05,6.158350151963532e-05,6.622899672947824e-05,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,hitting/bounded/greater-than/k-100,0.0005033334891777486,1.0416995792184025e-05,0.0004944167558278423,0.0005359062524803448,0.0004981875026714988,0.0005141869987710379,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,power/10,0.000558458996238187,4.395507858134806e-06,0.0005535309937840793,0.0005615727532131132,0.0005552500006160699,0.0005600834992947057,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,power/100,0.0005767084949184209,1.1666998034343123e-05,0.000570115000300575,0.0005988539996906184,0.000570708500163164,0.0005965204982203431,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,power/2,0.0004307710041757673,1.6039994079619646e-06,0.00042952075818902813,0.0004324375040596351,0.0004300419968785718,0.0004316050441047992,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,race/forward-committor,0.0005917914968449622,1.1061987606808543e-05,0.0005804272586829029,0.0006017190062266309,0.0005837500066263601,0.0005998955020913854,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,return/bounded/k-10,6.28749985480681e-05,2.8330032364465296e-06,6.09580019954592e-05,6.669850336038508e-05,6.116649456089363e-05,6.493749970104545e-05,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,return/bounded/k-100,0.0005030835018260404,5.083500582259148e-06,0.0004991252499166876,0.0005431564968603197,0.0005002079997211695,0.0005158959975233302,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,return/mean-recurrence,0.000703729507222306,4.666493623517454e-06,0.0007003335012996104,0.000712822253262857,0.0007010630069999024,0.0007083960008458234,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,simulation/10000,0.0799938124982873,0.0002418335061520338,0.0797305214946391,0.08018485375214368,0.0797729580081068,0.08016725050401874,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,simulation/100000,0.7881520625014673,0.0026166875104536302,0.7850916772476921,0.7899343644967303,0.7858497289998922,0.789222562496434,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,stationary,0.00018756249482976273,1.6874910215847194e-06,0.0001864692530944012,0.0001900417555589229,0.0001867079990915954,0.00018922899471363053,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,structure/classes-cold,5.124999734107405e-05,1.1664960766211152e-06,5.077074820292182e-05,5.283375139697455e-05,5.09169913129881e-05,5.22084956173785e-05,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,structure/classes-lifecycle,0.000930437003262341,6.562499038409442e-06,0.0009239582541340496,0.0009367187522002496,0.0009256455014110543,0.0009330419998150319,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,structure/classes-warm/access,2.162895500077866e-07,7.415997970383716e-10,2.154885751224356e-07,2.1683537488570437e-07,2.1581874971161596e-07,2.166895501432009e-07,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,structure/classes-warm/consumed,1.7423416502424517e-06,2.1987500076647837e-08,1.721080225252081e-06,1.7762510251486674e-06,1.7228541502845473e-06,1.7535916995257138e-06,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,structure/irreducible-cold,5.200000305194408e-05,1.1039883247576654e-06,4.884400186710991e-05,5.270775000099093e-05,5.041699478169903e-05,5.224999040365219e-05,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,structure/irreducible-warm,2.2819994992460125e-07,4.062450170749816e-09,2.2508025067509151e-07,2.369197751249885e-07,2.2572084999410436e-07,2.3277710060938262e-07,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,visits/bounded-expectation/k-10,3.162500070175156e-05,3.749955794773996e-07,3.127075615338981e-05,3.196874604327604e-05,3.139549517072737e-05,3.1729505280964077e-05,30 +pydtmc,low-outdegree-n0025-s31415,low-outdegree,25,31415,visits/bounded-expectation/k-100,9.479150321567431e-05,5.004985723644495e-07,9.430225327378139e-05,9.53227536228951e-05,9.458400018047541e-05,9.529200178803876e-05,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,construction/public-consumed,0.0025143750026472844,5.916495865676552e-06,0.002507958997739479,0.002518052246159641,0.0025110830029007047,0.002516999993531499,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,evolution/k-10,8.697900193510577e-05,6.67001586407423e-07,8.65420006448403e-05,8.857349894242361e-05,8.668750524520874e-05,8.808299753582105e-05,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,evolution/k-100,0.00031883350311545655,1.4164907042868435e-06,0.0003171777570969425,0.0003201767467544414,0.0003175830061081797,0.0003196890591425472,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,evolution/one-step,6.327049777610227e-05,6.249902071431279e-07,6.269750520004891e-05,6.40004982415121e-05,6.299999949987978e-05,6.358299287967384e-05,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,finite-time/n-step/k-10,8.568750490667298e-05,9.995055734179914e-07,8.499999239575118e-05,8.69272553245537e-05,8.516700472682714e-05,8.631355940451612e-05,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,finite-time/n-step/k-100,0.0003194165037712082,1.4164979802444577e-06,0.00031805200342205353,0.00032080200253403746,0.00031845697340031624,0.0003203130139809218,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,finite-time/observation/k-10,8.499999967170879e-05,6.869959179311991e-07,8.47604896989651e-05,8.657325815875083e-05,8.485450234729797e-05,8.602050365880132e-05,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,finite-time/observation/k-100,0.0003173125078319572,1.7500060494057834e-06,0.0003162392458762042,0.00032040675068856217,0.0003167914754158119,0.0003189375056535937,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,finite-time/step,1.4999968698248267e-06,4.1996827349066734e-08,1.4590041246265173e-06,1.6147496353369206e-06,1.4590041246265173e-06,1.5830009942874312e-06,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,hitting-probability/cold-all-states,0.00018172899581259117,1.1454976629465818e-06,0.00018097975043929182,0.00018379100947640836,0.00018129100499209017,0.00018245850515086204,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,hitting-time/cold-all-states,0.0003697914944496006,2.207991201430559e-06,0.0003678127541206777,0.00037244775012368336,0.0003685414994833991,0.00037158350460231304,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,hitting/bounded/at-most/k-10,8.72289965627715e-05,9.585055522620678e-07,8.65935035108123e-05,8.858373985276558e-05,8.66250047693029e-05,8.81870073499158e-05,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,hitting/bounded/at-most/k-100,0.00079552050010534,7.750495569780469e-06,0.0007768545001454186,0.0008021880057640374,0.0007854790019337088,0.0007992116261448245,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,hitting/bounded/exact/k-10,8.650050585856661e-05,8.739880286157131e-07,8.521875497535802e-05,8.712525595910847e-05,8.572899969294667e-05,8.687500667292625e-05,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,hitting/bounded/exact/k-100,0.0007807290021446534,6.250003934837878e-06,0.0007754795042274054,0.0008205107442336157,0.0007761250017210841,0.0007877704993006773,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,hitting/bounded/greater-than/k-10,8.750000415602699e-05,8.330025593750179e-07,8.701024489710107e-05,8.91144954948686e-05,8.70829971972853e-05,8.879200322553515e-05,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,hitting/bounded/greater-than/k-100,0.0007771665041218512,6.458496500272304e-06,0.0007711772523180116,0.0007854899995436426,0.0007722500013187528,0.0007810829993104562,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,power/10,0.0013813334953738376,4.187495505902916e-06,0.0013774272556474898,0.001385312501952285,0.0013797919964417815,0.0013845829962519929,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,power/100,0.001418625506630633,1.64374869200401e-05,0.0013935732458776329,0.0014341359928948805,0.001408687501680106,0.001427808648077189,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,power/2,0.0007118959983927198,3.6874989746138453e-06,0.0007073749984556343,0.0007149482480599545,0.0007093540043570101,0.0007137499924283475,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,race/forward-committor,0.0014250204985728487,1.289549982175231e-05,0.0014175107535265852,0.0014777395044802688,0.0014208535067155026,0.0014534890629875005,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,return/bounded/k-10,8.666650683153421e-05,1.062995579559356e-06,8.573925151722506e-05,8.773975059739314e-05,8.595850522397086e-05,8.756299939705059e-05,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,return/bounded/k-100,0.0007792085016262718,3.0625014915131032e-06,0.000776916498580249,0.0007833332529116888,0.0007773334946250543,0.0007820036331395385,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,return/mean-recurrence,0.0017093540009227581,2.524950832594186e-05,0.001681739497144008,0.0017273542507609818,0.0016859999959706329,0.0017259579908568412,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,simulation/10000,0.08017083349841414,0.0006182500001159497,0.07956589574678219,0.08084013524785405,0.07990425000025425,0.08051647949469043,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,simulation/100000,0.8200331664993428,0.005607541497738566,0.7963724897417706,0.8229816037419369,0.8037972290039761,0.8225660209936905,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,stationary,0.00043260450183879584,4.125002305954695e-06,0.0004299580032238737,0.00043752024430432357,0.0004306250048102811,0.0004369795060483739,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,structure/classes-cold,0.00010012499842559919,8.540009730495512e-07,9.919825606630184e-05,0.00010083324741572142,9.947949729394168e-05,0.00010054151553049451,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,structure/classes-lifecycle,0.002634937503898982,6.6879947553388774e-06,0.0026298332486476284,0.002642187497258419,0.002631479495903477,0.002641500497702509,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,structure/classes-warm/access,2.193833002820611e-07,9.916991984937338e-10,2.1636667479469907e-07,2.198332997068064e-07,2.1781039977213367e-07,2.1953329996904358e-07,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,structure/classes-warm/consumed,3.0322208505822348e-06,6.658349593635287e-09,3.017770799488062e-06,3.037920825590845e-06,3.022795899596531e-06,3.0377791998034806e-06,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,structure/irreducible-cold,9.685449185781181e-05,1.0834992281161249e-06,9.461424997425638e-05,9.769775351742283e-05,9.583300561644137e-05,9.733349725138396e-05,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,structure/irreducible-warm,2.246437499707099e-07,8.979004633147339e-10,2.2408227523555978e-07,2.2568540043721442e-07,2.2424369855798433e-07,2.2554165043402463e-07,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,visits/bounded-expectation/k-10,5.1875002100132406e-05,6.45501131657511e-07,5.1583254389697686e-05,5.2853996749036014e-05,5.162500019650906e-05,5.2584000513888896e-05,30 +pydtmc,low-outdegree-n0050-s01729,low-outdegree,50,1729,visits/bounded-expectation/k-100,0.00012918699940200895,9.795039659366012e-07,0.00012845800665672868,0.00013033300638198853,0.00012852099462179467,0.00013016754091950132,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,construction/public-consumed,0.002487187499355059,9.604002116248012e-06,0.0024789062481431756,0.0025020834946190007,0.002482291507476475,0.002497791501809843,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,evolution/k-10,8.710400288691744e-05,7.915004971437156e-07,8.64274988998659e-05,8.816650370135903e-05,8.679099846631289e-05,8.772899309406057e-05,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,evolution/k-100,0.00032047949207480997,1.6879857867024839e-06,0.0003190205025020987,0.0003223332460038364,0.00031966700043994933,0.000321854000503663,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,evolution/one-step,6.308349838946015e-05,5.210022209212184e-07,6.260375084821135e-05,6.424000457627699e-05,6.277099600993097e-05,6.350000330712646e-05,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,finite-time/n-step/k-10,8.606249321019277e-05,1.2079981388524175e-06,8.501075353706256e-05,8.728099783184007e-05,8.545850141672418e-05,8.679150050738826e-05,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,finite-time/n-step/k-100,0.0003205204993719235,3.2710013329051435e-06,0.000317635502142366,0.00032503125112270936,0.00031822900200495496,0.0003227085035177879,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,finite-time/observation/k-10,8.55624966789037e-05,7.710041245445609e-07,8.491650442010723e-05,8.637525024823844e-05,8.51875010994263e-05,8.608349889982492e-05,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,finite-time/observation/k-100,0.0003171044954797253,2.8124995878897607e-06,0.00031543700606562197,0.00032140624171006493,0.00031581249641021714,0.0003200472030584933,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,finite-time/step,1.4999968698248267e-06,8.300412446260452e-08,1.4170072972774506e-06,1.6144986147992313e-06,1.45800004247576e-06,1.5625046216882765e-06,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,hitting-probability/cold-all-states,0.0001860210031736642,1.5420009731315076e-06,0.00018461475701769814,0.000188635505764978,0.00018529199587646872,0.000187312500202097,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,hitting-time/cold-all-states,0.00036633299896493554,1.8124992493540049e-06,0.00036474950320553035,0.0003701665045809932,0.000365312494977843,0.0003676250053104013,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,hitting/bounded/at-most/k-10,8.679150778334588e-05,1.041495124809444e-06,8.552075814804994e-05,8.71144948177971e-05,8.579200220992789e-05,8.70829971972853e-05,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,hitting/bounded/at-most/k-100,0.0007808954978827387,5.81199856242165e-06,0.000777937748352997,0.0008079167564574163,0.0007784789922880009,0.0007953329986776225,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,hitting/bounded/exact/k-10,8.575000538257882e-05,8.335118764080107e-07,8.512474960298277e-05,8.684324711794034e-05,8.537499525118619e-05,8.64375033415854e-05,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,hitting/bounded/exact/k-100,0.0007906254977569915,6.103997293394059e-06,0.0007849895009712782,0.0007963542448123917,0.0007892920039012097,0.0007952919986564666,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,hitting/bounded/greater-than/k-10,8.708349923836067e-05,7.704948075115681e-07,8.655224883113988e-05,8.797925329417922e-05,8.687499212101102e-05,8.783300290815532e-05,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,hitting/bounded/greater-than/k-100,0.0007745000038994476,8.750008419156075e-06,0.0007689895028306637,0.0009220834981533699,0.0007706454998697154,0.0008483125056955032,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,power/10,0.0013826869981130585,5.500507541000843e-06,0.0013791142591799144,0.0013921672434662469,0.0013812910037813708,0.0013878335012122989,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,power/100,0.001406521005264949,1.1187003110535443e-05,0.0013968850034871139,0.0014205522493284661,0.0014003749965922907,0.0014171660004649311,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,power/2,0.0007116249980754219,3.4370023058727384e-06,0.0007092295090842526,0.0007168019947130233,0.0007096664994605817,0.0007144584960769862,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,race/forward-committor,0.0014546874954248779,3.8545040297321975e-06,0.0014499585013254546,0.0014583544980268925,0.001452041498851031,0.0014575204986613244,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,return/bounded/k-10,8.612500096205622e-05,7.084963726811111e-07,8.509400504408404e-05,8.656250429339707e-05,8.558350236853585e-05,8.633350080344826e-05,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,return/bounded/k-100,0.0007844580031814985,2.771499566733837e-06,0.0007810314928065054,0.0007867505046306178,0.0007830000104149804,0.0007857500022510067,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,return/mean-recurrence,0.001708479001536034,2.5062996428459883e-05,0.0016762607483542524,0.0017322190033155493,0.001696979503321927,0.001730832998873666,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,simulation/10000,0.08062095800414681,0.0003525830034050159,0.08041132275684504,0.08277914550490095,0.08048981321862812,0.08178552099707304,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,simulation/100000,0.8030764584982535,0.006801937488489784,0.7969086975062964,0.8159167084959336,0.7981797499960521,0.8102999164984794,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,stationary,0.00043529149843379855,3.3960022847168148e-06,0.0004315627447795123,0.0004383650011732243,0.00043320850090822205,0.00043743749847635627,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,structure/classes-cold,9.874999523162842e-05,1.5625046216882765e-06,9.73015048657544e-05,0.0001003437464532908,9.766699804458767e-05,0.00010014602721639677,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,structure/classes-lifecycle,0.0026534165008342825,1.4937497326172888e-05,0.002631458755786298,0.0026638014933269005,0.002640792001329828,0.0026586244930513203,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,structure/classes-warm/access,2.1667914988938718e-07,2.8534996090456365e-10,2.164031749998685e-07,2.1698855052818544e-07,2.1647710018442012e-07,2.167916994949337e-07,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,structure/classes-warm/consumed,3.007610450003995e-06,5.670850805472359e-09,3.005182274864637e-06,3.0171687503752763e-06,3.006258350069402e-06,3.015116700407816e-06,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,structure/irreducible-cold,9.722950198920444e-05,7.710041245445609e-07,9.614599184715189e-05,9.783325003809296e-05,9.63749989750795e-05,9.752099867910147e-05,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,structure/irreducible-warm,2.250312507385388e-07,7.728507625870462e-10,2.24603125025169e-07,2.2950314996705855e-07,2.2474794968729838e-07,2.270790095826669e-07,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,visits/bounded-expectation/k-10,5.185399641050026e-05,4.79492882732302e-07,5.149999924469739e-05,5.235424032434821e-05,5.152100493432954e-05,5.2041999879293144e-05,30 +pydtmc,low-outdegree-n0050-s02718,low-outdegree,50,2718,visits/bounded-expectation/k-100,0.00012856249668402597,6.460031727328897e-07,0.00012794824579032138,0.00012917700587422587,0.00012812500062864274,0.00012879200221505016,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,construction/public-consumed,0.002502604002074804,1.1396004993002862e-05,0.002491635241312906,0.002513458501198329,0.0024979589943541214,0.0025122090009972453,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,evolution/k-10,8.839600195642561e-05,1.0625008144415915e-06,8.705225627636537e-05,8.898949454305694e-05,8.733350114198402e-05,8.879302095010644e-05,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,evolution/k-100,0.0003157500032102689,1.541498932056129e-06,0.0003139889959129505,0.00031713500357000157,0.00031479200697503984,0.0003168955081491731,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,evolution/one-step,6.343750283122063e-05,8.539936970919371e-07,6.247900091693737e-05,6.386449604178779e-05,6.279150693444535e-05,6.370800656441133e-05,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,finite-time/n-step/k-10,8.568799967179075e-05,8.540009730495512e-07,8.488525418215431e-05,8.65420006448403e-05,8.495849760947749e-05,8.635449921712279e-05,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,finite-time/n-step/k-100,0.00031962500361260027,2.1460000425577164e-06,0.0003176877507939935,0.00032185424424824305,0.00031854150438448414,0.00032083298719953746,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,finite-time/observation/k-10,8.633350080344826e-05,9.584982763044536e-07,8.526025703758933e-05,8.70732546900399e-05,8.554200758226216e-05,8.658299339003861e-05,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,finite-time/observation/k-100,0.00031572899752063677,2.1244995878078043e-06,0.0003143124922644347,0.00032038525023381226,0.00031470900285057724,0.00031879149901214987,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,finite-time/step,1.4999968698248267e-06,4.1996827349066734e-08,1.4582510630134493e-06,1.5419936971738935e-06,1.4590041246265173e-06,1.5410041669383645e-06,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,hitting-probability/cold-all-states,0.00018331249884795398,1.7920101527124643e-06,0.0001816354997572489,0.00018653150618774816,0.00018195850134361535,0.0001850835033110343,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,hitting-time/cold-all-states,0.0003673960018204525,2.0625084289349616e-06,0.0003661042464955244,0.00036998950599809177,0.0003667504934128374,0.0003695210034493357,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,hitting/bounded/at-most/k-10,8.718750177649781e-05,6.869959179311991e-07,8.651100870338269e-05,8.782275108387694e-05,8.68540009832941e-05,8.749999688006938e-05,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,hitting/bounded/at-most/k-100,0.0007950204962980933,7.645503501407802e-06,0.000780416503403103,0.0007999787594599184,0.0007880359355112886,0.000798478999058716,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,hitting/bounded/exact/k-10,8.504200377501547e-05,4.5850174501538277e-07,8.484425052301958e-05,8.630200318293646e-05,8.497899398207664e-05,8.587499905843288e-05,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,hitting/bounded/exact/k-100,0.0007786874994053505,4.521003575064242e-06,0.0007747609961370472,0.0007850309993955307,0.0007763125031488016,0.0007827499939594418,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,hitting/bounded/greater-than/k-10,8.718699973542243e-05,5.83502696827054e-07,8.662499385536648e-05,8.778149640420452e-05,8.666546218591976e-05,8.772900037001818e-05,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,hitting/bounded/greater-than/k-100,0.0007886665043770336,7.291993824765086e-06,0.0007847187443985604,0.0007966770099301357,0.0007863749997341074,0.0007946879995870404,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,power/10,0.0013771665107924491,6.832997314631939e-06,0.0013692712527699769,0.0013819682462781202,0.0013713954976992682,0.0013812085016979836,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,power/100,0.0014107289971434511,1.95419997908175e-05,0.0013980627518321853,0.001433854500646703,0.0014040000023669563,0.0014302709969342686,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,power/2,0.0007085624965839088,2.4379914975725114e-06,0.0007060829993861262,0.0007104789983713999,0.0007065588461045991,0.0007091670122463256,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,race/forward-committor,0.0014461875034612603,5.562003934755921e-06,0.0014405212459678296,0.0014496042458631564,0.0014425824409045162,0.0014486459986073896,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,return/bounded/k-10,8.645799971418455e-05,7.709968485869467e-07,8.584425813751295e-05,8.735399751458317e-05,8.608350617578253e-05,8.706249354872853e-05,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,return/bounded/k-100,0.0007765624977764674,3.2289972295984626e-06,0.0007733542552159633,0.0007796772515575867,0.000774583502789028,0.0007793339900672436,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,return/mean-recurrence,0.0017223959948751144,1.187450106954202e-05,0.0017004692454065662,0.0017291039948759135,0.00171312500606291,0.001726687500195112,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,simulation/10000,0.07963781250145985,0.00030039550620131195,0.07945472924620844,0.08103489600762259,0.07951229149330175,0.08046087500406429,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,simulation/100000,0.7998537710009259,0.00553685399790993,0.7955668959984905,0.8106356977441465,0.7976282499876106,0.8064154789899476,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,stationary,0.00043787449976662174,4.582994733937085e-06,0.00042692724673543125,0.00044047899791621603,0.00043372950312914327,0.0004394999996293336,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,structure/classes-cold,0.00010014549479819834,2.3749962565489113e-06,9.849974594544619e-05,0.00010569800360826775,9.885399776976556e-05,0.00010404150089016184,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,structure/classes-lifecycle,0.0026454789986019023,1.6187499568331987e-05,0.002634280994243454,0.002675208252185257,0.002636916993651539,0.0026557710007182322,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,structure/classes-warm/access,2.1831039994140154e-07,1.3062490324955606e-09,2.1699480021197813e-07,2.195426743128337e-07,2.175916997657623e-07,2.1904375025769694e-07,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,structure/classes-warm/consumed,3.0148541998642033e-06,5.681199399987265e-09,3.0105302510492037e-06,3.020934350206517e-06,3.011447899916675e-06,3.017277100298088e-06,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,structure/irreducible-cold,9.675049659563228e-05,2.0204970496706665e-06,9.365599908051081e-05,9.861474609351717e-05,9.533350385027006e-05,9.827050234889612e-05,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,structure/irreducible-warm,2.2647709993179888e-07,3.1436989957001017e-09,2.2344062490446957e-07,2.2982289956416935e-07,2.2465209985966793e-07,2.2701455018250273e-07,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,visits/bounded-expectation/k-10,5.154149403097108e-05,4.1701423469930887e-07,5.120800051372498e-05,5.21042529726401e-05,5.129149940330535e-05,5.195850826567039e-05,30 +pydtmc,low-outdegree-n0050-s31415,low-outdegree,50,31415,visits/bounded-expectation/k-100,0.0001299170107813552,8.955030352808535e-07,0.00012891674123238772,0.00013074950038571842,0.00012958350271219388,0.00013016699813306332,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,construction/public-consumed,0.009099750001041684,6.954150012461469e-05,0.009064104255230632,0.009301207752287155,0.009070875006727874,0.009206416500092018,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,evolution/k-10,0.00013687499449588358,8.545030141249299e-07,0.00013614575436804444,0.00013825000132783316,0.00013627099542645738,0.00013775000115856528,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,evolution/k-100,0.0004359795057098381,1.7290003597736359e-06,0.00043435374391265213,0.000437738995969994,0.00043479149462655187,0.0004372710027382709,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,evolution/one-step,0.00010604099952615798,1.1450028978288174e-06,0.00010514575114939362,0.00010753150127129629,0.00010537500202190131,0.00010712500807130709,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,finite-time/n-step/k-10,0.00013691649655811489,1.7710044630803168e-06,0.00013556275735027157,0.00016586475248914212,0.00013570849841926247,0.00015147950034588575,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,finite-time/n-step/k-100,0.0004334995028330013,2.0419975044205785e-06,0.00043147850010427646,0.000435447997006122,0.00043193699821131304,0.00043468749936437234,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,finite-time/observation/k-10,0.00013472950377035886,6.045011105015874e-07,0.00013419800234260038,0.0001354060041194316,0.00013439550093607977,0.00013506249524652958,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,finite-time/observation/k-100,0.0004355414930614643,2.4999899324029684e-06,0.0004339582483225968,0.00044142649494460784,0.000434354500612244,0.0004385209977044724,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,finite-time/step,2.7909991331398487e-06,8.299684850499034e-08,2.7089990908280015e-06,2.937256795121357e-06,2.749991836026311e-06,2.8330032364465296e-06,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,hitting-probability/cold-all-states,0.0008083545035333373,1.6880003386177123e-06,0.000806958501925692,0.0008107504982035607,0.0008075415025814436,0.0008090414921753109,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,hitting-time/cold-all-states,0.0016024165015551262,5.708003300242126e-06,0.001598551756615052,0.0016264477526419796,0.0015990419997251593,0.001624958502361551,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,hitting/bounded/at-most/k-10,0.000177708498085849,7.295020623132586e-07,0.0001770207454683259,0.0001785414970072452,0.00017720799951348454,0.00017835449398262426,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,hitting/bounded/at-most/k-100,0.0017040834936778992,5.520989361684769e-06,0.0016984169960778672,0.0017081877449527383,0.0017002079985104501,0.0017065204956452362,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,hitting/bounded/exact/k-10,0.0001759999940986745,7.920025382190943e-07,0.00017527075760881416,0.00017688575462670997,0.0001753329997882247,0.00017654200200922787,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,hitting/bounded/exact/k-100,0.0017046044958988205,9.208502888213843e-06,0.0017004895053105429,0.001789791502233129,0.0017011460004141554,0.001750646006257739,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,hitting/bounded/greater-than/k-10,0.00017762499919626862,1.2294985936023295e-06,0.00017683400074020028,0.0001789579982869327,0.00017737499729264528,0.0001784580070307129,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,hitting/bounded/greater-than/k-100,0.0017120625052484684,7.291499059647322e-06,0.00170565675580292,0.0017203019924636465,0.0017085829967982136,0.0017173334999824874,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,power/10,0.004733333502372261,6.885449693072587e-05,0.004682333255914273,0.004821634996915236,0.004698541502875742,0.004802958494110499,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,power/100,0.004696583506301977,5.668748781317845e-05,0.004653728748962749,0.004782843752764165,0.004662500003178138,0.004753322544092952,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,power/2,0.0015847289978410117,1.1958502000197768e-05,0.0015753645020595286,0.0015988957457011566,0.0015774999992572702,0.00159489599900553,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,race/forward-committor,0.004431978995853569,0.00010583350376691669,0.004306760492909234,0.00451297925246763,0.004363937507150695,0.004472646003705449,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,return/bounded/k-10,0.00017489549645688385,8.755087037570775e-07,0.00017403099263901822,0.00017566725728102028,0.00017433300672564656,0.00017550000484334305,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,return/bounded/k-100,0.001698666499578394,8.10450001154095e-06,0.0016913229956116993,0.001707801999145886,0.001692812002147548,0.0017039160011336207,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,return/mean-recurrence,0.005013896006857976,4.35204929090105e-05,0.004997708500013687,0.0051615205011330545,0.005000334000214934,0.0050927504926221445,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,simulation/10000,0.0848907079998753,0.0007358335060416721,0.08391671900608344,0.08547577049102983,0.08420395850407658,0.08538641650375212,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,simulation/100000,0.8450960625050357,0.0022712709978804924,0.8435346559999743,0.8487998542550486,0.8437385625002207,0.8473630419975962,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,stationary,0.0011871669994434342,1.1625001206994057e-05,0.0011786565009970218,0.001257875257579144,0.0011819165010820143,0.0012348335003480315,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,structure/classes-cold,0.00021741649834439158,1.1044976417906582e-06,0.00021684424791601487,0.00021943723913864233,0.00021708400163333863,0.00021889649360673502,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,structure/classes-lifecycle,0.009261479004635476,1.368700759485364e-05,0.00925408375042025,0.009291437494539423,0.009256062505301088,0.00927949949982576,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,structure/classes-warm/access,2.1619585022563115e-07,5.895999493077372e-10,2.156593753170455e-07,2.167843998904573e-07,2.1584375062957408e-07,2.1659422154698407e-07,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,structure/classes-warm/consumed,5.608397900505225e-06,1.2414600496413506e-08,5.597811500410898e-06,5.626376074724249e-06,5.602827099937713e-06,5.618720799975563e-06,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,structure/irreducible-cold,0.00020937500084983185,8.749993867240846e-07,0.0002089160007017199,0.00021093725808896124,0.00020908350415993482,0.00021037449914729223,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,structure/irreducible-warm,2.266354495077394e-07,1.5750498278066542e-09,2.2550729991053232e-07,2.41473949427018e-07,2.2600829979637637e-07,2.3459946187358568e-07,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,visits/bounded-expectation/k-10,9.475000115344301e-05,6.254995241761208e-07,9.412475628778338e-05,9.533375487080775e-05,9.425000462215394e-05,9.524999768473208e-05,30 +pydtmc,low-outdegree-n0100-s01729,low-outdegree,100,1729,visits/bounded-expectation/k-100,0.0002232289989478886,8.749993867240846e-07,0.00022230224931263365,0.0002239897548861336,0.00022241650003707036,0.0002239164969068952,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,construction/public-consumed,0.009028833504999056,1.9354498363099992e-05,0.009008270251797512,0.009045364502526354,0.009009832996525802,0.009041416495165322,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,evolution/k-10,0.00013639550161315128,9.995055734179914e-07,0.00013576100536738522,0.00013787549687549472,0.00013610400492325425,0.00013754149404121563,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,evolution/k-100,0.0004364374981378205,1.8124919733963907e-06,0.0004344580083852634,0.00043759374966612086,0.00043552100396482274,0.0004371670074760914,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,evolution/one-step,0.00010533300519455224,7.500057108700275e-07,0.00010470825145603158,0.00010614574784995057,0.00010489600390428677,0.00010591700265649706,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,finite-time/n-step/k-10,0.00013518749619834125,1.2294913176447153e-06,0.00013359374861465767,0.00013597924044006504,0.0001340819488177658,0.000135728987515904,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,finite-time/n-step/k-100,0.00043506250221980736,1.6874982975423336e-06,0.00043382325748098083,0.00043683400144800544,0.0004343335094745271,0.00043666599958669394,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,finite-time/observation/k-10,0.00013483300426742062,7.290072971954942e-07,0.00013407249571173452,0.00013539550491259433,0.00013431250408757478,0.0001352085018879734,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,finite-time/observation/k-100,0.00043733300117310137,4.250003257766366e-06,0.00043287475637043826,0.00044032274672645144,0.0004338749931775965,0.0004385419961181469,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,finite-time/step,2.791493898257613e-06,8.299684850499034e-08,2.7090027288068086e-06,2.8644935810007155e-06,2.749991836026311e-06,2.8124995878897607e-06,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,hitting-probability/cold-all-states,0.0007954580069053918,2.062493877019733e-06,0.0007941457442939281,0.0007991352431417909,0.00079460450069746,0.000798187502368819,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,hitting-time/cold-all-states,0.0015546249924227595,2.916996891144663e-06,0.0015520519882556982,0.0015584477478114422,0.0015525000053457916,0.0015557080041617155,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,hitting/bounded/at-most/k-10,0.00017768749967217445,8.954957593232393e-07,0.00017644775289227255,0.00017820799257606268,0.00017679200391285121,0.00017820799257606268,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,hitting/bounded/at-most/k-100,0.0017117710012826137,6.000009307172149e-06,0.001705916743958369,0.001717302260658471,0.0017079579993151128,0.0017147504986496642,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,hitting/bounded/exact/k-10,0.00017568749899510294,6.250047590583563e-07,0.00017528125681565143,0.00017659375589573756,0.00017549999756738544,0.00017633350216783583,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,hitting/bounded/exact/k-100,0.001707979005004745,7.062502845656127e-06,0.0017025627457769588,0.0017150630010291934,0.0017037714933394454,0.0017096669907914475,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,hitting/bounded/greater-than/k-10,0.00017764600488590077,9.169962140731514e-07,0.00017633349852985702,0.00017839525753515773,0.00017672899411991239,0.00017818749620346352,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,hitting/bounded/greater-than/k-100,0.0017102295023505576,6.124995707068592e-06,0.0017043440057022963,0.0017164272503578104,0.0017056459982995875,0.0017142290016636252,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,power/10,0.004759666997415479,4.991699825040996e-05,0.004701738998846849,0.004799416743480833,0.004724871873258963,0.004781388893206895,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,power/100,0.004815770997083746,4.6270994062069803e-05,0.004786936999153113,0.004896635757177137,0.004792104497028049,0.00487704200349981,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,power/2,0.0015796664956724271,5.166999471839517e-06,0.001573989742610138,0.0015839582520129625,0.0015756460052216426,0.001582124998094514,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,race/forward-committor,0.0044441659993026406,5.477049853652716e-05,0.004265520499757258,0.004491062751185382,0.004333835590296075,0.004474708504858427,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,return/bounded/k-10,0.00017541699344292283,7.289927452802658e-07,0.00017456199930165894,0.00017605174070922658,0.00017475000640843064,0.00017585400200914592,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,return/bounded/k-100,0.0016952294972725213,3.603992809075862e-06,0.0016898652465897612,0.0016975942598946858,0.001692562502285,0.0016971045042737387,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,return/mean-recurrence,0.005050792002293747,0.00018027149781119078,0.005034614754549693,0.0054426142560259905,0.005044000005000271,0.005430125005659647,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,simulation/10000,0.08444910399703076,0.00032247900526272133,0.08378064524731599,0.08466228125689668,0.08398750000196742,0.08461297949543223,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,simulation/100000,0.8356126459984807,0.0022186249916558154,0.8339925517502706,0.849466864256101,0.8343593335011974,0.8438379165017977,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,stationary,0.001184936991194263,5.166999471839517e-06,0.0011773850019380916,0.0011879892517754342,0.0011788955016527325,0.001187562505947426,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,structure/classes-cold,0.000216729000385385,2.2504900698550045e-06,0.00021503124662558548,0.00021916674450039864,0.00021529199148062617,0.00021862499852431938,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,structure/classes-lifecycle,0.009304437495302409,2.960449637612328e-05,0.009282083752623294,0.009376854504807852,0.009284707994083874,0.0093435419985326,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,structure/classes-warm/access,2.16854149766732e-07,1.5603996871504891e-09,2.1603230052278377e-07,2.2025522448529956e-07,2.1634574719428205e-07,2.1991249959683045e-07,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,structure/classes-warm/consumed,5.744808349118102e-06,1.3811664830427608e-07,5.613645849371096e-06,5.938366651025718e-06,5.641046145010478e-06,5.9304478505509904e-06,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,structure/irreducible-cold,0.000212646002182737,1.0420044418424368e-06,0.00021183324861340225,0.00021447925610118546,0.00021218799520283937,0.00021333301065169506,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,structure/irreducible-warm,2.2620624949922784e-07,9.187504474539452e-10,2.2546250074810815e-07,2.272958492540056e-07,2.2576418708922574e-07,2.27052099944558e-07,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,visits/bounded-expectation/k-10,9.44165003602393e-05,4.995017661713064e-07,9.406275057699531e-05,9.504125046078116e-05,9.416700049769133e-05,9.485400369158015e-05,30 +pydtmc,low-outdegree-n0100-s02718,low-outdegree,100,2718,visits/bounded-expectation/k-100,0.0002232289989478886,5.624970071949065e-07,0.00022270874978858046,0.00022378149878932163,0.00022285449813352898,0.00022364549658959731,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,construction/public-consumed,0.00909487499302486,2.5291505153290927e-05,0.009067990249604918,0.009119062746322015,0.00907679150259355,0.009114395499636885,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,evolution/k-10,0.0001358545050607063,9.375071385875344e-07,0.00013491649588104337,0.00013667700477526523,0.00013531250442611054,0.00013633350317832083,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,evolution/k-100,0.0004390204994706437,1.7295024008490145e-06,0.0004372497496660799,0.000440635751147056,0.00043747949530370533,0.0004400830002850853,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,evolution/one-step,0.00010639599349815398,8.544957381673157e-07,0.00010551025479799137,0.00010705174281611107,0.000105875005829148,0.00010679200204322115,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,finite-time/n-step/k-10,0.0001346455028397031,1.1245065252296627e-06,0.0001336562490905635,0.00013620825484395027,0.0001340000017080456,0.00013504200614988804,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,finite-time/n-step/k-100,0.00043858300341526046,2.187996869906783e-06,0.0004330312476668041,0.0004401042533572763,0.00043635400652419776,0.0004394584975671023,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,finite-time/observation/k-10,0.00013518700143322349,1.186999725177884e-06,0.00013416674119071104,0.00013672924251295626,0.00013447899254970253,0.0001362080074613914,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,finite-time/observation/k-100,0.0004365209970274009,1.3335011317394674e-06,0.0004348855036369059,0.00043744775030063465,0.0004350000017439015,0.0004371664981590584,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,finite-time/step,2.8124995878897607e-06,6.249319994822145e-08,2.7909991331398487e-06,2.874992787837982e-06,2.7909991331398487e-06,2.8340000426396728e-06,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,hitting-probability/cold-all-states,0.0008023125046747737,1.916509063448757e-06,0.0008011142563191243,0.000806707757874392,0.000801416506874375,0.0008047630210057832,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,hitting-time/cold-all-states,0.0015777080043335445,3.0834999051876366e-06,0.0015754170017316937,0.0015831459968467243,0.001576354494318366,0.0015805420043761842,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,hitting/bounded/at-most/k-10,0.0001771460083546117,5.835099727846682e-07,0.00017671849855105393,0.00017833375750342384,0.00017691700486466289,0.00017789549747249112,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,hitting/bounded/at-most/k-100,0.0017109790060203522,5.395995685830712e-06,0.0017054692580131814,0.0017160940005851444,0.0017067500011762604,0.0017146244936157018,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,hitting/bounded/exact/k-10,0.00017641649901634082,1.6454941942356527e-06,0.0001750937444739975,0.0002275317456224002,0.00017568699695402756,0.00020266699721105397,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,hitting/bounded/exact/k-100,0.0017093540009227581,6.541493348777294e-06,0.0017029482551151887,0.0017154584966192488,0.0017047709989128634,0.0017139795018010773,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,hitting/bounded/greater-than/k-10,0.00017749999824445695,1.0625008144415915e-06,0.00017652074166107923,0.00017851049415185116,0.0001770000089891255,0.00017791700520319864,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,hitting/bounded/greater-than/k-100,0.0017059375022654422,4.6670029405504465e-06,0.0017011352501867805,0.0017102702440752182,0.0017016874990076758,0.0017093959977501072,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,power/10,0.004710645996965468,4.1541497921571136e-05,0.004675801748817321,0.004752249496959848,0.004684249499405269,0.0047285624968935736,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,power/100,0.004780124996614177,5.743699875893071e-05,0.00474237474554684,0.004854073500609957,0.0047535419871564955,0.004837915999814868,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,power/2,0.0015913335009827279,1.4354496670421213e-05,0.0015829270014364738,0.0017768019970390014,0.001584958503372036,0.0016763960084063,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,race/forward-committor,0.004401686994242482,2.356300683459267e-05,0.004281823010387598,0.004417729498527478,0.004339942867227364,0.0044129579910077155,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,return/bounded/k-10,0.00017500000103609636,1.104010152630508e-06,0.00017386499166605063,0.0001759687511366792,0.00017414549802197143,0.00017579199629835784,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,return/bounded/k-100,0.001694666498224251,4.500499926507473e-06,0.001690333247097442,0.001698750496871071,0.0016904170042835176,0.0016968129930319265,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,return/mean-recurrence,0.005414000501332339,4.624900611815974e-05,0.004939104244840564,0.005447364248539088,0.005000500503228977,0.005439041502540931,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,simulation/10000,0.08406631250545615,0.00030256249010562897,0.08374993699908373,0.08433127074749791,0.08381468749576015,0.08422331249312265,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,simulation/100000,0.8563846254910459,0.013371792003454175,0.8405543647568265,0.8665589172524051,0.8483091039961437,0.8639992709940998,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,stationary,0.001198687001306098,2.147900522686541e-05,0.0011823335007647984,0.0012636562423722353,0.001189020498713944,0.0012622920039575547,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,structure/classes-cold,0.00021787500008940697,1.0420044418424368e-06,0.0002162812525057234,0.0002188122489314992,0.00021693749295081943,0.00021864550944883376,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,structure/classes-lifecycle,0.0092861669982085,3.131249832222238e-05,0.009256082998035708,0.009316801995737478,0.009269104004488327,0.009314708506281022,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,structure/classes-warm/access,2.175582994823344e-07,5.416499334387416e-10,2.1685625069949312e-07,2.1797917579533532e-07,2.1706460029236043e-07,2.1792289990116843e-07,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,structure/classes-warm/consumed,5.6088604491378646e-06,1.0368749644839798e-08,5.600435374435619e-06,5.62098544978653e-06,5.602654790327506e-06,5.61454790076823e-06,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,structure/irreducible-cold,0.00021197900059632957,1.979497028514743e-06,0.00020987500101909973,0.00021313600154826418,0.00021033299708506092,0.00021283349633449689,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,structure/irreducible-warm,2.257020998513326e-07,4.854497092310314e-10,2.2534689996973612e-07,2.2734789999958592e-07,2.254291503049899e-07,2.263957998366095e-07,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,visits/bounded-expectation/k-10,9.472900273976848e-05,3.954992280341685e-07,9.451050209463574e-05,9.53227499849163e-05,9.456300176680088e-05,9.485449845669791e-05,30 +pydtmc,low-outdegree-n0100-s31415,low-outdegree,100,31415,visits/bounded-expectation/k-100,0.00022383300529327244,5.83502696827054e-07,0.0002232077531516552,0.0002242285008833278,0.0002234585044789128,0.00022402049216907471,30 +pydtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,construction/public-consumed,0.054885978999664076,0.00027341649547452107,0.05420746899835649,0.055034228760632686,0.054412500001490116,0.055027499998686835,30 +pydtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,evolution/k-10,0.00033085449831560254,2.1460000425577164e-06,0.0003290315071353689,0.0003333647437102627,0.0003295835049357265,0.00033181199978571385,30 +pydtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,evolution/k-100,0.0012401249987306073,4.895504389423877e-06,0.0012364895046630409,0.001246509749762481,0.0012374169891700149,0.00124449950089911,30 +pydtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,evolution/one-step,0.00023935450735734776,2.124994352925569e-06,0.00023787523969076574,0.00024191700504161417,0.0002384590043220669,0.0002413749971310608,30 +pydtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,hitting-probability/cold-all-states,0.010343813002691604,2.898000821005553e-05,0.010316833748220233,0.010405322249425808,0.010328857851345673,0.010369249997893348,30 +pydtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,hitting-time/cold-all-states,0.02019185399694834,2.237500302726403e-05,0.020174635508737992,0.020219073001499055,0.020176583500870038,0.020204228996590246,30 +pydtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,power/10,0.02911256250081351,6.735450006090105e-05,0.029047124495264143,0.029175406245485647,0.02906022900424432,0.029144020496460143,30 +pydtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,power/100,0.02927397949679289,0.0001596254951437004,0.029119426755642053,0.029430875005346024,0.029172083501180168,0.029398728998785373,30 +pydtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,power/2,0.006475729001977015,4.925000393996015e-05,0.006429833505535498,0.006589416501810774,0.0064432499930262566,0.0065161664970219135,30 +pydtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,race/forward-committor,0.02475212450372055,0.0001107500065700151,0.024705375002668006,0.024991843245516066,0.02473591699526878,0.0249530414948822,30 +pydtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,return/mean-recurrence,0.026347582999733277,0.0001919784990604967,0.026024021506600548,0.02650093775082496,0.026304666498617735,0.02645574999769451,30 +pydtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,simulation/10000,0.0974147710003308,0.0008014999984879978,0.09577254125179024,0.09802772925104364,0.0965111045006779,0.09782218035434198,30 +pydtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,simulation/100000,0.9636856045035529,0.0026795414960361086,0.9601328860007925,0.9656233229943609,0.9629836039966904,0.9651340209966293,30 +pydtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,stationary,0.00761574999341974,1.5958496078383178e-05,0.007600395500048762,0.0076341557505656965,0.007603333004226442,0.007627187493199017,30 +pydtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,structure/classes-cold,0.0006989585017436184,4.395493306219578e-06,0.0006952500079933088,0.0007056877511786297,0.0006971039983909577,0.0007021455021458678,30 +pydtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,structure/classes-lifecycle,0.054903999996895436,0.00014495799405267462,0.054711104501620866,0.05504201050644042,0.05476264599565184,0.055008583498420194,30 +pydtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,structure/classes-warm/access,2.175395995436702e-07,4.750007065012967e-10,2.167354257835541e-07,2.1782602489111015e-07,2.1708749991375953e-07,2.1774590515633464e-07,30 +pydtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,structure/classes-warm/consumed,1.3475039599870797e-05,1.6370849334634755e-08,1.3461688500319723e-05,1.3553915599914036e-05,1.3463374999992084e-05,1.3515706250473158e-05,30 +pydtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,structure/irreducible-cold,0.0006780620024073869,3.1255040084943175e-06,0.0006764685022062622,0.000681458754115738,0.0006773124987375923,0.0006809169935877435,30 +pydtmc,low-outdegree-n0250-s01729,low-outdegree,250,1729,structure/irreducible-warm,2.248291995783802e-07,3.479006409179405e-10,2.2453642486652823e-07,2.2517815013998188e-07,2.2471664924523794e-07,2.2512290015583858e-07,30 +pydtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,construction/public-consumed,0.0541239165031584,5.772899748990312e-05,0.05408342774535413,0.054196270248212386,0.05409281250467757,0.05415433349844534,30 +pydtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,evolution/k-10,0.0003294789930805564,1.4370016288012266e-06,0.00032812550125527196,0.0003309165040263906,0.0003287699613792938,0.0003306459984742105,30 +pydtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,evolution/k-100,0.0012477505079004914,2.561981091275811e-06,0.0012450207432266325,0.0012499687400122639,0.0012462500017136335,0.0012493329995777458,30 +pydtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,evolution/one-step,0.000239250497543253,1.4369943528436124e-06,0.00023761499687680043,0.00024053149536484852,0.00023822949879104272,0.0002399789955234155,30 +pydtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,hitting-probability/cold-all-states,0.010335728999052662,3.1853996915742755e-05,0.010304646009899443,0.010367406004661461,0.010314291008398868,0.010360958505771123,30 +pydtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,hitting-time/cold-all-states,0.020286500002839603,2.12500017369166e-05,0.020264332997612655,0.020301291999203386,0.02026881300844252,0.020297437498811632,30 +pydtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,power/10,0.028793125005904585,0.00018185398948844522,0.028612010246433783,0.028972844003874343,0.02873672899295343,0.028951562504516914,30 +pydtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,power/100,0.029596854001283646,0.00018206249660579488,0.029105979003361426,0.029731770999205764,0.02934060400002636,0.029691707997699268,30 +pydtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,power/2,0.006416062009520829,1.4270510291680694e-05,0.006408072742488002,0.006454010246670805,0.006408874498447403,0.00644425000064075,30 +pydtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,race/forward-committor,0.025028103998920415,0.0002456875081406906,0.024884041748009622,0.025327853749331553,0.02493152100214502,0.025306187504611444,30 +pydtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,return/mean-recurrence,0.02643964550225064,6.212500011315569e-05,0.026385509994724998,0.026503219247388188,0.02641202099766815,0.0264748955014511,30 +pydtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,simulation/10000,0.097646750495187,0.0005841044985572807,0.09710691649888759,0.09871937450225232,0.09712454199325293,0.09809839600347914,30 +pydtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,simulation/100000,0.9716813534978428,0.008144624494889285,0.9666029482541489,0.9894335102508194,0.96729291700467,0.9831742506750742,30 +pydtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,stationary,0.0076086459957878105,2.7083500754088163e-05,0.007589656499476405,0.007656510249944404,0.007597387820896984,0.0076457710019894876,30 +pydtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,structure/classes-cold,0.000704250494891312,5.062502168584615e-06,0.0007006870000623167,0.0007094484972185455,0.0007008959946688265,0.0007083177215463364,30 +pydtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,structure/classes-lifecycle,0.05490079149603844,6.179200136102736e-05,0.05486056249719695,0.05502636449455167,0.054880646006495226,0.054976104001980275,30 +pydtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,structure/classes-warm/access,2.1684379971702582e-07,3.917491994798165e-10,2.1646975001203827e-07,2.172656495531555e-07,2.1663749939762055e-07,2.1713954993174413e-07,30 +pydtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,structure/classes-warm/consumed,1.3554097850283143e-05,1.476249963161539e-08,1.3542797900299775e-05,1.3570342674938728e-05,1.3543379149632528e-05,1.356757085013669e-05,30 +pydtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,structure/irreducible-cold,0.0006802295029046945,3.7084901123307645e-06,0.0006764689933334012,0.0006838857480033766,0.0006788954924559221,0.0006817294924985617,30 +pydtmc,low-outdegree-n0250-s02718,low-outdegree,250,2718,structure/irreducible-warm,2.2470204930868931e-07,1.5624995285179547e-09,2.2343640084727667e-07,2.271323493914679e-07,2.2375830012606456e-07,2.2661874972982332e-07,30 +pydtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,construction/public-consumed,0.0544832294981461,0.00037989599513821304,0.054113364250952145,0.05486446874056128,0.054275208502076566,0.054813666494737845,30 +pydtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,evolution/k-10,0.00033058349799830467,1.8124992493540049e-06,0.0003285729981143959,0.00033213549613719806,0.00032916650525294244,0.0003315855608889251,30 +pydtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,evolution/k-100,0.0012459790013963357,1.9164945115335286e-06,0.0012429270063876174,0.0012475622534111608,0.0012444164967746474,0.0012472505040932447,30 +pydtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,evolution/one-step,0.00023906200658529997,1.479500497225672e-06,0.00023777074602548964,0.0002407294996373821,0.00023820900241844356,0.0002403745020274073,30 +pydtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,hitting-probability/cold-all-states,0.010255937995680142,3.235448821214959e-05,0.010239271254249616,0.01035298975330079,0.010243261097275537,0.010290708494721912,30 +pydtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,hitting-time/cold-all-states,0.020139353997365106,0.00012049999349983409,0.0200852185007534,0.02029645850052475,0.020094458508538082,0.02027872850158019,30 +pydtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,power/10,0.028592187496542465,0.00016106250404845923,0.028479937758675078,0.028809646242734743,0.028515790996607393,0.028744541996275075,30 +pydtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,power/100,0.029720521495619323,0.0001301039956160821,0.02963364550669212,0.02993741675527417,0.029660853506356943,0.029828083504980896,30 +pydtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,power/2,0.006507041995064355,0.00010758349526440725,0.006417760243493831,0.006800843751989305,0.006421958503779024,0.006786291487514973,30 +pydtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,race/forward-committor,0.025262729497626424,0.0003905835037585348,0.024874479244317627,0.02562180250242818,0.025024312497407664,0.02547624999715481,30 +pydtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,return/mean-recurrence,0.02694312550011091,0.0007148544973460957,0.026348343744757585,0.02820657224583556,0.026548041991190985,0.028026145497278776,30 +pydtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,simulation/10000,0.09691895800642669,0.000320791506965179,0.09671140624777763,0.09763782350273686,0.09676845800277079,0.09724041699519148,30 +pydtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,simulation/100000,0.9736414790022536,0.014288790996943135,0.961013896001532,0.989393562249461,0.9665636669960804,0.9852625415005605,30 +pydtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,stationary,0.007739874999970198,0.00010010400728788227,0.007670739749300992,0.007842593502573436,0.007688834011787549,0.007786479494825471,30 +pydtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,structure/classes-cold,0.00069881299714325,1.1061994882766157e-05,0.0006915207486599684,0.000711520500772167,0.0006931660027476028,0.0007083749951561913,30 +pydtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,structure/classes-lifecycle,0.05496762449183734,0.00012835400411859155,0.05480491624621209,0.05509208325020154,0.05486093749641441,0.05506866650102893,30 +pydtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,structure/classes-warm/access,2.1800000031362286e-07,7.458002073690457e-10,2.1552397556661163e-07,2.1843849935976324e-07,2.1677123291738096e-07,2.183294077804021e-07,30 +pydtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,structure/classes-warm/consumed,1.3434783349657663e-05,1.2054100079695003e-08,1.3426125024852809e-05,1.3448161450287442e-05,1.3427916650834957e-05,1.3445093700283905e-05,30 +pydtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,structure/irreducible-cold,0.0006824380034231581,4.875495505984873e-06,0.0006779582508897875,0.0006945109962543938,0.0006790829938836396,0.000685270999383647,30 +pydtmc,low-outdegree-n0250-s31415,low-outdegree,250,31415,structure/irreducible-warm,2.266937997774221e-07,7.333503162954e-10,2.2494684999401216e-07,2.270072996907402e-07,2.2564579994650558e-07,2.2692289931001142e-07,30 +pydtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,construction/public-consumed,0.22203516649460653,0.0017946040024980903,0.2196482500003185,0.22304994774822262,0.22052931250073016,0.22249129200645257,30 +pydtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,evolution/k-10,0.0009886039988487028,6.416649557650089e-05,0.0009284372426918708,0.0010556149936746806,0.0009530624884064309,0.0010441250051371753,30 +pydtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,evolution/k-100,0.004066875502758194,8.125498425215483e-06,0.0040579582419013605,0.004072792002261849,0.00405960399803007,0.00407150000683032,30 +pydtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,evolution/one-step,0.0006931460011401214,2.6333007554057986e-05,0.000618864745774772,0.0007090524995874148,0.0006737294897902757,0.0007030829947325401,30 +pydtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,hitting-probability/cold-all-states,0.07471952150081052,0.0001488960042479448,0.07457271874591243,0.07485166700280388,0.07460978281524148,0.07477022950479295,30 +pydtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,hitting-time/cold-all-states,0.14471560400124872,0.00020966699230484664,0.14456398950278526,0.14493615650644642,0.14460999999573687,0.14487170850043185,30 +pydtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,power/10,0.12063956249767216,0.00031910400139167905,0.12005010450229747,0.12087253149366006,0.12034004149609245,0.12082739650213625,30 +pydtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,power/100,0.12386616649746429,0.000607791000220459,0.12324033374534338,0.12433989550117985,0.12351104150002357,0.12429183399945032,30 +pydtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,power/2,0.0236670000012964,8.489549509249628e-05,0.02361239599849796,0.023806947760022013,0.023645875000511296,0.023739312498946674,30 +pydtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,race/forward-committor,0.11586041649570689,0.0004613124910974875,0.11562766673887381,0.11658918725515832,0.11571949999051867,0.11641433350450825,30 +pydtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,return/mean-recurrence,0.11774964599317173,0.0018844589940272272,0.11606753076193854,0.12253750999298063,0.11664741700224113,0.12012943799345521,30 +pydtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,simulation/10000,0.11781722900195746,0.00038389598921639845,0.11665531249673222,0.11809905174231972,0.11716216649801936,0.118034125000122,30 +pydtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,simulation/100000,1.1676836040060152,0.004190499988908414,1.1624698747582443,1.1715107082454779,1.16432139549579,1.1709286039986182,30 +pydtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,stationary,0.04799320800520945,0.00013635450159199536,0.04789531300048111,0.04827403125455021,0.04790024999238085,0.04820977099734591,30 +pydtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,structure/classes-cold,0.0019206249999115244,7.146001735236496e-06,0.0019161042473569978,0.0019423749945417512,0.0019180194733053213,0.001938374996825587,30 +pydtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,structure/classes-lifecycle,0.2235825415045838,0.00245247899874812,0.22152188575273613,0.22867310425499454,0.2225096879992634,0.22471229149959981,30 +pydtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,structure/classes-warm/access,2.172874992538709e-07,5.854002665728326e-10,2.1669167472282425e-07,2.1781665018352215e-07,2.168458500818815e-07,2.1764795092167333e-07,30 +pydtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,structure/classes-warm/consumed,2.842275834918837e-05,1.2993750715394826e-08,2.8412113548620252e-05,2.843697814932966e-05,2.8415979099372634e-05,2.843388750043232e-05,30 +pydtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,structure/irreducible-cold,0.0019053335054195486,1.0708004992920905e-05,0.0018977807412738912,0.0019281664972368162,0.0019002289918716997,0.001920583497849293,30 +pydtmc,low-outdegree-n0500-s01729,low-outdegree,500,1729,structure/irreducible-warm,2.2468539973488078e-07,5.270492692943736e-10,2.2421772519010118e-07,2.2530314963660204e-07,2.2427080111810938e-07,2.2504789958475157e-07,30 +pydtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,construction/public-consumed,0.22063418750622077,0.0015412915017805062,0.21906754174415255,0.22208495799714,0.21941010400041705,0.22197791699727532,30 +pydtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,evolution/k-10,0.000982812991423998,5.874499038327485e-06,0.0009800417501537595,0.0009903332465910353,0.000980749995505903,0.0009872290029306896,30 +pydtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,evolution/k-100,0.004078333506186027,2.4646004021633416e-05,0.004068833248311421,0.0041470520045550074,0.004072540992638096,0.004110020505322609,30 +pydtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,evolution/one-step,0.0006924585031811148,1.6874997527338564e-05,0.0006771142507204786,0.0007097185007296503,0.0006798339891247451,0.0007064790042932145,30 +pydtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,hitting-probability/cold-all-states,0.07412843749625608,7.239600381581113e-05,0.07407671875989763,0.07420246924448293,0.07410018800146645,0.07418193750345381,30 +pydtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,hitting-time/cold-all-states,0.14461243749974528,0.0001682920046732761,0.14450658324858523,0.14490589524939423,0.14453685449552722,0.14478521823511983,30 +pydtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,power/10,0.12055293749290286,0.0006065420093364082,0.1200374060026661,0.12122820850345306,0.12023508299898822,0.12106327050423715,30 +pydtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,power/100,0.12392785400879802,0.00043606200779322535,0.12347875049817958,0.12427833324909443,0.12363950000144541,0.12421366649505217,30 +pydtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,power/2,0.02377652100403793,0.00011158349661855027,0.02364117724209791,0.023870395751146134,0.023681083504925482,0.023847395998018328,30 +pydtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,race/forward-committor,0.11551341699669138,0.00019987500127172098,0.11534768774436088,0.11574241700145649,0.1154129999995348,0.11562202101049479,30 +pydtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,return/mean-recurrence,0.12246925049839774,0.0022511455026688054,0.1164372397470288,0.124184499738476,0.11667945850058459,0.12362712499452755,30 +pydtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,simulation/10000,0.11700097900029505,0.00025841649767244235,0.11678082275466295,0.11854544774905662,0.1168371664971346,0.11847979149752064,30 +pydtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,simulation/100000,1.173186916501436,0.0011977495087194256,1.171728052002436,1.1742821567531792,1.172091521002585,1.1739043540001148,30 +pydtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,stationary,0.048021374495874625,0.00017247849609702826,0.04790978124947287,0.05251135475191404,0.04793116649670992,0.052131625001493376,30 +pydtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,structure/classes-cold,0.0019432499975664541,2.1375002688728273e-05,0.0019275627491879277,0.0019728022562048864,0.00193331250193296,0.001966666502994485,30 +pydtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,structure/classes-lifecycle,0.22371522949833889,0.0030064790043979883,0.22122807299820124,0.22653104150595027,0.22305616699304665,0.22429666649986757,30 +pydtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,structure/classes-warm/access,2.1642704959958792e-07,6.833506631664922e-10,2.1513750034500845e-07,2.17030250132666e-07,2.1601140826533083e-07,2.1693959934054876e-07,30 +pydtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,structure/classes-warm/consumed,2.841929374990286e-05,1.597284935996657e-08,2.8407608350607914e-05,2.9171310449601152e-05,2.840923960029613e-05,2.8774141649773812e-05,30 +pydtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,structure/irreducible-cold,0.0019000624961336143,1.0645999282132834e-05,0.0018913652529590763,0.001920479247928597,0.0018920005022664554,0.0019121669974992983,30 +pydtmc,low-outdegree-n0500-s02718,low-outdegree,500,2718,structure/irreducible-warm,2.2597914939979092e-07,1.1374497262295382e-09,2.2482709937321489e-07,2.2699379951518496e-07,2.2531044960487632e-07,2.266053485436714e-07,30 +pydtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,construction/public-consumed,0.22236793749470962,0.0016181249884539284,0.22072705225582467,0.223814457996923,0.22105439550068695,0.223727937998774,30 +pydtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,evolution/k-10,0.0009755414939718321,1.2041986337862909e-05,0.0009629687483538873,0.0009860520003712736,0.0009634995076339692,0.0009836250028456561,30 +pydtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,evolution/k-100,0.004077437493833713,1.0437499440740794e-05,0.0040693749942875,0.004091437254828634,0.00407075000111945,0.004087791996425949,30 +pydtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,evolution/one-step,0.0006838539993623272,8.583003364037722e-06,0.0006760104952263646,0.0007044060002954211,0.0006778125025448389,0.000695167007506825,30 +pydtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,hitting-probability/cold-all-states,0.07475054199312581,7.822948828106746e-05,0.07468488525773864,0.07482666723808507,0.07472008350305259,0.07480131249758415,30 +pydtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,hitting-time/cold-all-states,0.14506447949679568,0.0002726259917835705,0.14482859399868175,0.14539301049808273,0.14488454200909473,0.14532437500020023,30 +pydtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,power/10,0.12013212499732617,0.0006214169989107177,0.11964753075153567,0.12128639600268798,0.1197211039980175,0.12102581249928335,30 +pydtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,power/100,0.1241496040020138,0.0006563330025528558,0.12366741649748292,0.1254053542506881,0.12380462500732392,0.1249186874993029,30 +pydtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,power/2,0.023832333499740344,0.00013662500714417547,0.023710833254881436,0.024005332747037755,0.023778479000611696,0.023945458997332025,30 +pydtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,race/forward-committor,0.11557679150428157,0.0002655205025803298,0.11541104149728199,0.11603280225244816,0.11542945799737936,0.11590533349954057,30 +pydtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,return/mean-recurrence,0.12269991700304672,0.0004574790000333451,0.11789881200456875,0.12299337500007823,0.12006064599700039,0.12295072899723891,30 +pydtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,simulation/10000,0.11824602050910471,0.0001743334942148067,0.11791651000385173,0.1183907712547807,0.11814010400121333,0.11834818749048281,30 +pydtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,simulation/100000,1.1823475625060382,0.005908770493988413,1.1733503119903617,1.1850557295074395,1.1738187500013737,1.1834737890379985,30 +pydtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,stationary,0.04825689600693295,0.0001478755148127675,0.04814594774143188,0.04843868799798656,0.04816606250096811,0.048400500003481284,30 +pydtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,structure/classes-cold,0.0019475414956104942,1.9833503756672144e-05,0.0019338122510816902,0.0019728017468878534,0.0019366665001143701,0.0019673749993671663,30 +pydtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,structure/classes-lifecycle,0.22290662500017788,0.0016814580012578517,0.22051428124905215,0.2237707495041832,0.22060483299719635,0.2234762084990507,30 +pydtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,structure/classes-warm/access,2.17358300142223e-07,6.083493644837399e-10,2.1686247491743417e-07,2.1803015042678453e-07,2.1711664958274924e-07,2.1787084988318382e-07,30 +pydtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,structure/classes-warm/consumed,2.841943125022226e-05,1.2133349810027787e-08,2.8407101000266267e-05,2.843068125002901e-05,2.8412358349305577e-05,2.842686669973773e-05,30 +pydtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,structure/irreducible-cold,0.0019026874942937866,1.2041498848702759e-05,0.0018914897555077914,0.0019198437439627014,0.001897583504614886,0.0019109795030090027,30 +pydtmc,low-outdegree-n0500-s31415,low-outdegree,500,31415,structure/irreducible-warm,2.2636039939243348e-07,3.729008312802593e-10,2.2320627467706799e-07,2.2666145014227367e-07,2.2484170040115715e-07,2.2654999993392267e-07,30 +pydtmc,low-outdegree-n1000-s01729,low-outdegree,1000,1729,construction/public-consumed,0.9042220624905895,0.00960664600279415,0.8937802812542941,0.9098862605060276,0.8998650410067057,0.9073294757015901,30 +pydtmc,low-outdegree-n1000-s01729,low-outdegree,1000,1729,evolution/k-10,0.00400735400035046,0.0003278540098108351,0.003793187497649342,0.004454510493815178,0.0039000830001896247,0.0043719374953070655,30 +pydtmc,low-outdegree-n1000-s01729,low-outdegree,1000,1729,evolution/k-100,0.021146479004528373,0.00035389550612308085,0.02084688550166902,0.021965229247143725,0.02097666700137779,0.021508666497538798,30 +pydtmc,low-outdegree-n1000-s01729,low-outdegree,1000,1729,evolution/one-step,0.0019615620039985515,0.0002494584987289272,0.0018302400021639187,0.002299853746080771,0.0018503750034142286,0.002264166992972605,30 +pydtmc,low-outdegree-n1000-s01729,low-outdegree,1000,1729,simulation/10000,0.15949800049565965,0.001167708498542197,0.15871205224539153,0.161143750003248,0.15912829149601748,0.16086622899456415,30 +pydtmc,low-outdegree-n1000-s01729,low-outdegree,1000,1729,simulation/100000,1.59501810400252,0.008439791992714163,1.583757187006995,1.5995008327445248,1.5885967504946166,1.599120207996748,30 +pydtmc,low-outdegree-n1000-s01729,low-outdegree,1000,1729,structure/classes-cold,0.005982103997666854,2.7707988920155913e-05,0.0059565730080066714,0.006011677240167046,0.00596462500107009,0.005994458500936162,30 +pydtmc,low-outdegree-n1000-s01729,low-outdegree,1000,1729,structure/classes-lifecycle,0.907647916006681,0.013334937502804678,0.8941144474993052,0.92035214574571,0.897019417003321,0.9188893755053869,30 +pydtmc,low-outdegree-n1000-s01729,low-outdegree,1000,1729,structure/classes-warm/access,2.167979495425243e-07,4.687506589107236e-10,2.1652707509929314e-07,2.2300102500594224e-07,2.1668544941348953e-07,2.196062501752749e-07,30 +pydtmc,low-outdegree-n1000-s01729,low-outdegree,1000,1729,structure/classes-warm/consumed,5.842661040005624e-05,4.1647950274637126e-08,5.838614162494196e-05,5.8466954174946295e-05,5.839145204954548e-05,5.846324995000032e-05,30 +pydtmc,low-outdegree-n1000-s01729,low-outdegree,1000,1729,structure/irreducible-cold,0.005883021003683098,1.4042001566849649e-05,0.005872687506780494,0.005913698249059962,0.005875437993381638,0.005899686999327969,30 +pydtmc,low-outdegree-n1000-s01729,low-outdegree,1000,1729,structure/irreducible-warm,2.2565000035683625e-07,8.833507308736491e-10,2.2497815007227473e-07,2.2717187530361117e-07,2.2526249958900734e-07,2.2689785037073307e-07,30 +pydtmc,low-outdegree-n1000-s02718,low-outdegree,1000,2718,construction/public-consumed,0.8958537705038907,0.005283687503833789,0.8921464159902825,0.9020299684962083,0.8934851669910131,0.900164312493871,30 +pydtmc,low-outdegree-n1000-s02718,low-outdegree,1000,2718,evolution/k-10,0.004279228996892925,0.00039641700277570635,0.0035870727551809978,0.0046013022438273765,0.0037878750008530915,0.004558396001812071,30 +pydtmc,low-outdegree-n1000-s02718,low-outdegree,1000,2718,evolution/k-100,0.021598583007289562,0.0006819995105615817,0.020774572498339694,0.022102374754467746,0.020903750497382134,0.022019895994162653,30 +pydtmc,low-outdegree-n1000-s02718,low-outdegree,1000,2718,evolution/one-step,0.0019141250013490207,0.00017045850108843297,0.0018172287600464188,0.0022929792503418867,0.0018339585076319054,0.002255333005450666,30 +pydtmc,low-outdegree-n1000-s02718,low-outdegree,1000,2718,simulation/10000,0.15791847949731164,0.0004999380034860224,0.15753248925102525,0.15929013549612137,0.1575902499971562,0.15918218750448432,30 +pydtmc,low-outdegree-n1000-s02718,low-outdegree,1000,2718,simulation/100000,1.5817760835052468,0.004046396003104746,1.5787889582497883,1.5867542182531906,1.5796405415021582,1.5853080420056358,30 +pydtmc,low-outdegree-n1000-s02718,low-outdegree,1000,2718,structure/classes-cold,0.005986187505186535,1.716650149319321e-05,0.005978219254757278,0.006005520499456907,0.005978916000458412,0.005998478998662904,30 +pydtmc,low-outdegree-n1000-s02718,low-outdegree,1000,2718,structure/classes-lifecycle,0.9073682084926986,0.005922499498410616,0.8923653857455065,0.9117042497564398,0.9041219170030672,0.9111088539939374,30 +pydtmc,low-outdegree-n1000-s02718,low-outdegree,1000,2718,structure/classes-warm/access,2.1984165068715812e-07,1.622948911972327e-09,2.1769275008409752e-07,2.2113850100140554e-07,2.188750499044545e-07,2.2095630152762166e-07,30 +pydtmc,low-outdegree-n1000-s02718,low-outdegree,1000,2718,structure/classes-warm/consumed,5.837121250078781e-05,3.5814549482892516e-08,5.834160417543899e-05,5.8461119849380333e-05,5.835318544995971e-05,5.840689789984026e-05,30 +pydtmc,low-outdegree-n1000-s02718,low-outdegree,1000,2718,structure/irreducible-cold,0.0058996454972657375,9.957999282050878e-06,0.00589105175822624,0.0059131044981768355,0.00589693750225706,0.005907625003601424,30 +pydtmc,low-outdegree-n1000-s02718,low-outdegree,1000,2718,structure/irreducible-warm,2.2383959949365816e-07,1.129199517890797e-09,2.2295207563729491e-07,2.255354498629458e-07,2.234187493741047e-07,2.2490835035569033e-07,30 +pydtmc,low-outdegree-n1000-s31415,low-outdegree,1000,31415,construction/public-consumed,0.8950388750017737,0.00878814549650997,0.8835281667525123,0.9014130837458652,0.8885679794984753,0.8972748544911155,30 +pydtmc,low-outdegree-n1000-s31415,low-outdegree,1000,31415,evolution/k-10,0.004461354001250584,0.00021839600231032819,0.004238041499775136,0.004645562748919474,0.004345458000898361,0.0045837084981030785,30 +pydtmc,low-outdegree-n1000-s31415,low-outdegree,1000,31415,evolution/k-100,0.021015166501456406,0.000803542003268376,0.020220749989675824,0.021700292243622243,0.0204682914991281,0.02123416650283616,30 +pydtmc,low-outdegree-n1000-s31415,low-outdegree,1000,31415,evolution/one-step,0.0023283750051632524,7.170849130488932e-05,0.002146750000974862,0.002377510249061743,0.002262084002722986,0.002359707999858074,30 +pydtmc,low-outdegree-n1000-s31415,low-outdegree,1000,31415,simulation/10000,0.16098987450095592,0.0017652925016591325,0.15904323925860808,0.1623985727528634,0.15973218750150409,0.16229189549630973,30 +pydtmc,low-outdegree-n1000-s31415,low-outdegree,1000,31415,simulation/100000,1.585652146000939,0.002672750000783708,1.5837409277482948,1.5887903014991025,1.5841893190839982,1.5873365414954606,30 +pydtmc,low-outdegree-n1000-s31415,low-outdegree,1000,31415,structure/classes-cold,0.005957020999630913,2.247950033051893e-05,0.005935302247962682,0.005982406495604664,0.005941021001490299,0.005964916999801062,30 +pydtmc,low-outdegree-n1000-s31415,low-outdegree,1000,31415,structure/classes-lifecycle,0.9082617289896007,0.011011458496795967,0.8990446977513784,0.9188175104936818,0.9062084164979751,0.9159496874999604,30 +pydtmc,low-outdegree-n1000-s31415,low-outdegree,1000,31415,structure/classes-warm/access,2.1956040000077338e-07,2.0874504116363885e-09,2.177625003241701e-07,2.3164270060078708e-07,2.1861045024706984e-07,2.265358680415375e-07,30 +pydtmc,low-outdegree-n1000-s31415,low-outdegree,1000,31415,structure/classes-warm/consumed,5.853603335053777e-05,3.831896006886407e-07,5.823849165062711e-05,5.922471664962359e-05,5.8261437071796544e-05,5.920928330015158e-05,30 +pydtmc,low-outdegree-n1000-s31415,low-outdegree,1000,31415,structure/irreducible-cold,0.00590937500965083,1.2438002158887684e-05,0.0058922707503370475,0.005914365003263811,0.005898916002479382,0.0059130415102117695,30 +pydtmc,low-outdegree-n1000-s31415,low-outdegree,1000,31415,structure/irreducible-warm,2.2447290029958823e-07,8.021001121960667e-10,2.2384479998436292e-07,2.2768960006942507e-07,2.241791502456181e-07,2.2600209995289335e-07,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,construction/public-consumed,0.00034795800456777215,3.1874951673671603e-06,0.00034519775363150984,0.00035259348805993795,0.000346187996910885,0.00035093800397589803,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,evolution/k-10,5.1208509830757976e-05,7.710186764597893e-07,5.0499736971687526e-05,5.210448580328375e-05,5.07919758092612e-05,5.18540182383731e-05,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,evolution/k-100,0.00026149999757763,1.937500201165676e-06,0.0002573647507233545,0.00026303099730284885,0.00025906250812113285,0.00026264600455760956,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,evolution/one-step,2.9562506824731827e-05,5.420006345957518e-07,2.9135240765754133e-05,3.0687995604239404e-05,2.9208007617853582e-05,3.0520473956130445e-05,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,finite-time/n-step/k-10,4.9645997933112085e-05,3.5451375879347324e-07,4.942749365000054e-05,5.0510483561083674e-05,4.950001311954111e-05,5.004199920222163e-05,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,finite-time/n-step/k-100,0.00025766649923752993,3.207984264008701e-06,0.0002553329977672547,0.0002621145176817663,0.0002563330053817481,0.000260979009908624,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,finite-time/observation/k-10,4.9812006182037294e-05,8.754868758842349e-07,4.9031266826204956e-05,5.0802504119928926e-05,4.916649777442217e-05,5.058347596786916e-05,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,finite-time/observation/k-100,0.000257708496064879,2.1659943740814924e-06,0.00025561526126693934,0.00025989523419411853,0.0002561444485763786,0.00025924999499693513,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,finite-time/step,9.165087249130011e-07,6.200571078807116e-08,8.33999365568161e-07,9.477589628659189e-07,8.545030141249299e-07,9.170034900307655e-07,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,hitting-probability/cold-all-states,4.4104017433710396e-05,1.4169927453622222e-06,4.2885505536105484e-05,4.5698492613155395e-05,4.304150934331119e-05,4.485399404074997e-05,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,hitting-time/cold-all-states,9.168748511001468e-05,1.97898771148175e-06,8.986500324681401e-05,9.403074363945052e-05,9.033299284055829e-05,9.356299415230751e-05,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,hitting/bounded/at-most/k-10,4.320847801864147e-05,6.039772415533662e-07,4.2802254029084e-05,4.4093249016441405e-05,4.287500632926822e-05,4.3583495425991714e-05,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,hitting/bounded/at-most/k-100,0.0003308955056127161,1.8544960767030716e-06,0.00032926022686297074,0.00033315649488940835,0.00033012138883350414,0.0003327089943923056,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,hitting/bounded/exact/k-10,4.1708495700731874e-05,5.629844963550568e-07,4.1332998080179095e-05,4.232273204252124e-05,4.133401671424508e-05,4.220849950797856e-05,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,hitting/bounded/exact/k-100,0.0003357920068083331,1.1255033314228058e-06,0.00033492723741801456,0.0003371250058989972,0.0003352085186634213,0.0003367710014572367,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,hitting/bounded/greater-than/k-10,4.329151124693453e-05,3.7500285543501377e-07,4.300000728107989e-05,4.386474029161036e-05,4.3042004108428955e-05,4.360401362646371e-05,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,hitting/bounded/greater-than/k-100,0.0003366250020917505,2.4999899324029684e-06,0.0003342917625559494,0.00033914575033122674,0.0003350835031596944,0.00033841699769254774,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,power/10,0.0002871040051104501,1.3749959180131555e-06,0.0002859375163097866,0.00028995799948461354,0.0002863334957510233,0.0002879999956348911,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,power/100,0.0002905625005951151,1.7295096768066287e-06,0.0002888957387767732,0.000292188000457827,0.0002894999925047159,0.00029156247910577804,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,power/2,0.00028410401137080044,1.8124992493540049e-06,0.0002825727715389803,0.0002860939930542372,0.00028316699899733067,0.0002849375014193356,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,return/bounded/k-10,4.339599399827421e-05,4.789908416569233e-07,4.280224675312638e-05,4.367699148133397e-05,4.291650839149952e-05,4.354148404672742e-05,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,return/bounded/k-100,0.00033245800295844674,2.7710048016160727e-06,0.0003311354957986623,0.00033705199894029647,0.00033120799344033003,0.00033627050288487226,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,stationary,7.250050839502364e-05,8.13015503808856e-07,7.17290022294037e-05,7.338522846112028e-05,7.183299749158323e-05,7.279199780896306e-05,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,structure/classes-cold,1.858349423855543e-05,3.9600126910954714e-07,1.830224209697917e-05,1.923975651152432e-05,1.833400165196508e-05,1.9145983969792724e-05,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,structure/classes-lifecycle,0.0003971044934587553,2.6039924705401063e-06,0.0003951247563236393,0.000402312733058352,0.0003953334962716326,0.0003997499879915267,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,structure/classes-warm/access,2.1562710026046263e-07,1.0312491212971639e-09,2.1512297607841903e-07,2.1767397556686776e-07,2.1524790063267573e-07,2.1738545037806035e-07,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,structure/classes-warm/consumed,9.34600000618957e-07,1.0472950816620197e-08,9.219458741426933e-07,9.43167699733749e-07,9.284020503400826e-07,9.412812505615875e-07,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,structure/cyclic-classes-cold,0.00025002050097100437,2.229004167020321e-06,0.00024832250346662477,0.0002530207348172553,0.0002485630102455616,0.0002522705035516992,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,structure/cyclic-classes-warm,1.1374020497896708e-06,2.575050166342346e-09,1.1340009761624971e-06,1.1396259993489365e-06,1.1356728995451703e-06,1.1388750004698523e-06,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,structure/irreducible-cold,1.758350117597729e-05,2.4950713850557804e-07,1.7375015886500478e-05,1.7833015590440482e-05,1.7479003872722387e-05,1.77919864654541e-05,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,structure/irreducible-warm,2.239312496385537e-07,1.266648177988821e-09,2.2250834954320455e-07,2.2458537714555863e-07,2.225833508418873e-07,2.244709001388401e-07,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,structure/period-cold,0.00011585399624891579,1.3534881873056293e-06,0.00011467777221696451,0.0001174057470052503,0.00011522900604177266,0.00011674949200823903,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,structure/period-warm,2.2945414821151645e-07,2.5874993298203018e-09,2.2770519863115624e-07,2.401666759396903e-07,2.285563008626923e-07,2.3614589881617575e-07,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,visits/bounded-expectation/k-10,1.9665996660478413e-05,2.2900348994880915e-07,1.9427250663284212e-05,1.9875005818903446e-05,1.9479513866826892e-05,1.9834013073705137e-05,30 +pydtmc,periodic-n0010-s01729,periodic,10,1729,visits/bounded-expectation/k-100,7.920850475784391e-05,1.1045049177482724e-06,7.830200775060803e-05,8.043725392781198e-05,7.856250158511102e-05,7.99375120550394e-05,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,construction/public-consumed,0.00034791650250554085,2.3124885046854615e-06,0.0003458230057731271,0.00035140576073899865,0.0003461875021457672,0.0003498125006444752,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,evolution/k-10,5.2104005590081215e-05,8.749921107664704e-07,5.116700776852667e-05,5.262502236291766e-05,5.129149940330535e-05,5.258299643173814e-05,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,evolution/k-100,0.00025977099721785635,4.5851629693061113e-07,0.00025933325377991423,0.00026023975806310773,0.00025941699277609587,0.00026020899531431496,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,evolution/one-step,2.945848973467946e-05,4.789908416569233e-07,2.9135517252143472e-05,3.0833747587166727e-05,2.9187503969296813e-05,2.9874994652345777e-05,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,finite-time/n-step/k-10,4.9208494601771235e-05,6.254995241761208e-07,4.872901627095416e-05,5.0489754357840866e-05,4.891699063591659e-05,5.002149555366486e-05,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,finite-time/n-step/k-100,0.0002571665099821985,1.478983904235065e-06,0.00025577101769158617,0.0002591872471384704,0.00025599999935366213,0.0002581664884928614,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,finite-time/observation/k-10,4.9666501581668854e-05,6.040063453838229e-07,4.903124499833211e-05,5.0156500947196037e-05,4.920799983665347e-05,5.004199920222163e-05,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,finite-time/observation/k-100,0.00026235400582663715,3.270979505032301e-06,0.00025497900060145184,0.00026472950412426144,0.00025843748881015927,0.0002638959849718958,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,finite-time/step,8.954957593232393e-07,6.250047590583563e-08,8.33999365568161e-07,9.580107871443033e-07,8.750066626816988e-07,9.374929504701868e-07,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,hitting-probability/cold-all-states,4.6291504986584187e-05,2.875021891668439e-06,4.373951378511265e-05,4.9604517698753625e-05,4.458300827536732e-05,4.92080143885687e-05,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,hitting-time/cold-all-states,9.160451008938253e-05,1.8124846974387765e-06,9.072901593754068e-05,9.4562245067209e-05,9.089599188882858e-05,9.362499986309558e-05,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,hitting/bounded/at-most/k-10,4.345799970906228e-05,7.079943316057324e-07,4.277074913261458e-05,4.416651790961623e-05,4.295801045373082e-05,4.3957988964393735e-05,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,hitting/bounded/at-most/k-100,0.000334249998559244,2.125001628883183e-06,0.0003326457444927655,0.0003364792501088232,0.00033291546678810847,0.0003362105864653131,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,hitting/bounded/exact/k-10,4.166649887338281e-05,4.5799242798238993e-07,4.114576586289331e-05,4.197924863547087e-05,4.1250503272749484e-05,4.183300188742578e-05,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,hitting/bounded/exact/k-100,0.0003319999959785491,1.5210098354145885e-06,0.0003240412479499355,0.0003326250007376075,0.0003281665121903643,0.0003324169956613332,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,hitting/bounded/greater-than/k-10,4.3624997488223016e-05,3.7500285543501377e-07,4.3343483412172645e-05,4.43122407887131e-05,4.3374995584599674e-05,4.4042011722922325e-05,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,hitting/bounded/greater-than/k-100,0.0003359789989190176,5.95799065195024e-06,0.00033135399280581623,0.0003438024941715412,0.0003329585015308112,0.0003410205099498853,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,power/10,0.000287041999399662,2.3120082914829254e-06,0.0002859894957509823,0.0002907605012296699,0.00028643700352404267,0.000289562507532537,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,power/100,0.0002933750074589625,3.895504050888121e-06,0.00028944824589416385,0.0002960625060950406,0.0002903749991673976,0.000295000005280599,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,power/2,0.0002861669927369803,1.8339778762310743e-06,0.00028441626636777073,0.0002887187438318506,0.0002846870047505945,0.0002871455071726814,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,return/bounded/k-10,4.3082996853627264e-05,3.335153451189399e-07,4.280149005353451e-05,4.341675958130509e-05,4.287500632926822e-05,4.333349352236837e-05,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,return/bounded/k-100,0.0003380000125616789,2.6039924705401063e-06,0.00033469726622570306,0.00034034375130431727,0.00033641648769844323,0.00033985349000431597,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,stationary,7.343750621657819e-05,8.750066626816988e-07,7.276050018845126e-05,7.468749390682206e-05,7.295800605788827e-05,7.427050149999559e-05,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,structure/classes-cold,1.8063015886582434e-05,3.1250237952917814e-07,1.77604888449423e-05,1.8364495190326124e-05,1.7853992176242173e-05,1.8228995031677186e-05,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,structure/classes-lifecycle,0.0004114165058126673,9.687471901997924e-06,0.00040383375744568184,0.0004280837529222481,0.0004054307129990775,0.00042110397771466523,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,structure/classes-warm/access,2.1814165083924307e-07,8.62451270222654e-10,2.175552253902424e-07,2.3673744944971986e-07,2.176353504182771e-07,2.2854370035929606e-07,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,structure/classes-warm/consumed,9.314958006143569e-07,4.814550629816949e-09,9.267406232538633e-07,9.361832744616549e-07,9.285083506256342e-07,9.358312483527698e-07,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,structure/cyclic-classes-cold,0.0002460630057612434,1.8124992493540049e-06,0.000244781251240056,0.0002484892538632266,0.00024527101777493954,0.0002470625040587038,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,structure/cyclic-classes-warm,1.1370061998604796e-06,2.0125007722526094e-09,1.1357948256772943e-06,1.1404791002860292e-06,1.1362353994627485e-06,1.1396499990951272e-06,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,structure/irreducible-cold,1.7457990907132626e-05,3.1250237952917814e-07,1.719798456178978e-05,1.7864498659037054e-05,1.7312500858679414e-05,1.7624988686293364e-05,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,structure/irreducible-warm,2.240812493255362e-07,4.458488547243181e-10,2.2366562552633696e-07,2.2452189878094943e-07,2.2379999863915145e-07,2.2433539998019113e-07,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,structure/period-cold,0.00011881299724336714,2.2085150703787804e-06,0.00011624975741142407,0.00012066673662047833,0.00011739549518097192,0.00012010450882371515,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,structure/period-warm,2.2988540004007519e-07,9.937517461366976e-10,2.2685627336613834e-07,2.3060730090946893e-07,2.284791989950463e-07,2.3052290052874016e-07,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,visits/bounded-expectation/k-10,1.9625003915280104e-05,3.7500285543501377e-07,1.925000105984509e-05,1.994772901525721e-05,1.9353989046067e-05,1.9895509467460215e-05,30 +pydtmc,periodic-n0010-s02718,periodic,10,2718,visits/bounded-expectation/k-100,7.933349115774035e-05,5.415058694779873e-07,7.876050949562341e-05,7.978075154824182e-05,7.881250348873436e-05,7.968749559950083e-05,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,construction/public-consumed,0.00035354201099835336,2.7500063879415393e-06,0.0003512602488626726,0.00035761473554885015,0.00035177048994228244,0.00035593750362750143,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,evolution/k-10,5.1083508878946304e-05,8.125061867758632e-07,5.046848673373461e-05,5.239601159701124e-05,5.0521004595793784e-05,5.206250352784991e-05,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,evolution/k-100,0.0002613124961499125,3.895998816005886e-06,0.0002566144830780104,0.00026375000015832484,0.0002586664923001081,0.00026295799762010574,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,evolution/one-step,2.9375500162132084e-05,4.795147106051445e-07,2.9010487196501344e-05,3.0770752346143126e-05,2.908398164436221e-05,2.9626042669406153e-05,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,finite-time/n-step/k-10,4.943799285683781e-05,4.379835445433855e-07,4.902076761936769e-05,5.0260503485333174e-05,4.916699253953993e-05,4.972900205757469e-05,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,finite-time/n-step/k-100,0.00025939600891433656,2.3960164980962873e-06,0.00025567749253241345,0.00026089625316672027,0.0002572499943198636,0.0002603330067358911,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,finite-time/observation/k-10,5.033348861616105e-05,7.920025382190943e-07,4.945824184687808e-05,5.077051173429936e-05,5.010449967812747e-05,5.0520990043878555e-05,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,finite-time/observation/k-100,0.0002608545037219301,2.7500209398567677e-06,0.0002580732325441204,0.0002633225085446611,0.00025845799245871603,0.0002622920001158491,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,finite-time/step,8.544884622097015e-07,2.1478626877069473e-08,8.330098353326321e-07,8.750066626816988e-07,8.33999365568161e-07,8.750066626816988e-07,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,hitting-probability/cold-all-states,4.4166503357701004e-05,9.790092008188367e-07,4.3416985135991126e-05,4.551000165520236e-05,4.356249701231718e-05,4.4832995627075434e-05,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,hitting-time/cold-all-states,9.191701246891171e-05,1.9790168153122067e-06,9.060401498572901e-05,9.511422831565142e-05,9.083349141292274e-05,9.322899859398603e-05,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,hitting/bounded/at-most/k-10,4.300000728107989e-05,3.125169314444065e-07,4.271924990462139e-05,4.340650048106909e-05,4.281201108824462e-05,4.3333013309165835e-05,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,hitting/bounded/at-most/k-100,0.0003354379878146574,3.23000131174922e-06,0.000332926501869224,0.000340260005032178,0.00033362500835210085,0.00033906300086528063,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,hitting/bounded/exact/k-10,4.127100692130625e-05,4.795001586899161e-07,4.087548586539924e-05,4.19687494286336e-05,4.1062492527998984e-05,4.17085102526471e-05,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,hitting/bounded/exact/k-100,0.0003332920023240149,1.1454976629465818e-06,0.00033265674574067816,0.0003347400124766864,0.00033304149110335857,0.00033402099506929517,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,hitting/bounded/greater-than/k-10,4.383301711641252e-05,7.500057108700275e-07,4.300000728107989e-05,4.4354012061376125e-05,4.33335080742836e-05,4.41879965364933e-05,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,hitting/bounded/greater-than/k-100,0.00032839599589351565,1.5829864423722029e-06,0.0003273437396273948,0.0003346457378938794,0.00032768750679679215,0.00033212755224667486,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,power/10,0.00028833300166297704,1.7705024220049381e-06,0.00028655175265157595,0.0002893752680392936,0.0002868745068553835,0.0002892079937737435,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,power/100,0.00029020849615335464,2.0210136426612735e-06,0.00028855226264568046,0.0002925735097960569,0.0002893544879043475,0.00029183298465795815,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,power/2,0.0002843959809979424,1.8544960767030716e-06,0.0002824062466970645,0.00028614525217562914,0.0002831874880939722,0.0002853545011021197,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,return/bounded/k-10,4.337451537139714e-05,6.870104698464274e-07,4.2968502384610474e-05,4.411449481267482e-05,4.300000728107989e-05,4.3812484364025295e-05,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,return/bounded/k-100,0.00033493750379420817,8.749921107664704e-07,0.00033446851739427075,0.00033592675026739016,0.00033458348480053246,0.00033577100839465857,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,stationary,7.291650399565697e-05,8.540082490071654e-07,7.218774408102036e-05,7.469850970664993e-05,7.235449447762221e-05,7.368750812020153e-05,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,structure/classes-cold,1.8416496459394693e-05,3.960158210247755e-07,1.8041995645035058e-05,1.882275682874024e-05,1.812499249354005e-05,1.8770995666272938e-05,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,structure/classes-lifecycle,0.00039995899714995176,3.042499884031713e-06,0.00039747899427311495,0.0004047707552672364,0.0003986040101153776,0.00040197950147558004,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,structure/classes-warm/access,2.1586874936474488e-07,5.500492989085773e-10,2.154271009203512e-07,2.165761005016975e-07,2.1556040010182186e-07,2.1623124921461568e-07,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,structure/classes-warm/consumed,9.425625001313165e-07,1.224584993906318e-08,9.304176499426831e-07,9.546957997372374e-07,9.325603998149745e-07,9.536041005048901e-07,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,structure/cyclic-classes-cold,0.0002461665135342628,1.687512849457562e-06,0.0002448227533022873,0.0002485627483110875,0.0002455209905747324,0.0002476250083418563,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,structure/cyclic-classes-warm,1.1356228496879339e-06,6.41244987491516e-09,1.1303531493467744e-06,1.1445635507698171e-06,1.1314583505736664e-06,1.1431458508013747e-06,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,structure/irreducible-cold,1.7771017155610025e-05,2.4950713850557804e-07,1.7666265193838626e-05,1.8468766938894987e-05,1.7687503714114428e-05,1.816649455577135e-05,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,structure/irreducible-warm,2.2271875059232116e-07,7.063004886731558e-10,2.219365007476881e-07,2.2310725034913048e-07,2.2204160050023347e-07,2.228646000730805e-07,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,structure/period-cold,0.00011737500608433038,1.3539829524233937e-06,0.00011639573494903743,0.00011940675176447257,0.00011670798994600773,0.00011877100041601807,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,structure/period-warm,2.277457999298349e-07,1.1291995178908103e-09,2.2670414982712828e-07,2.288031486386899e-07,2.273499994771555e-07,2.2834185867395718e-07,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,visits/bounded-expectation/k-10,1.977100328076631e-05,2.915039658546448e-07,1.955224433913827e-05,2.0333252905402333e-05,1.9583007087931037e-05,1.9917002646252513e-05,30 +pydtmc,periodic-n0010-s31415,periodic,10,31415,visits/bounded-expectation/k-100,7.793749682605267e-05,3.5349512472748756e-07,7.758400170132518e-05,7.842724153306335e-05,7.772899698466063e-05,7.81665148679167e-05,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,construction/public-consumed,0.0008291249978356063,9.270996088162065e-06,0.000823166235932149,0.000841354500153102,0.0008234584965975955,0.0008383959939237684,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,evolution/k-10,6.487499922513962e-05,6.455084076151252e-07,6.434351962525398e-05,6.594773731194437e-05,6.445850885938853e-05,6.55625026411144e-05,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,evolution/k-100,0.0002834375045495108,2.3124885046854615e-06,0.0002804165123961866,0.000285583249933552,0.000281603992334567,0.0002846670104190707,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,evolution/one-step,4.339599399827421e-05,1.104010152630508e-06,4.236425593262538e-05,4.452050052350387e-05,4.2728992411866784e-05,4.41455194959417e-05,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,finite-time/n-step/k-10,6.318748637568206e-05,7.084890967234969e-07,6.246849079616368e-05,6.378074613166973e-05,6.2603983678855e-05,6.352151103783399e-05,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,finite-time/n-step/k-100,0.0002817295171553269,2.2085150703787804e-06,0.0002803957540891133,0.0002863337431335822,0.0002807919809129089,0.0002841034875018522,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,finite-time/observation/k-10,6.306201976258308e-05,6.660120561718941e-07,6.271850725170225e-05,6.405248859664425e-05,6.27710105618462e-05,6.375156772264745e-05,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,finite-time/observation/k-100,0.0002793750027194619,1.0624935384839773e-06,0.0002784377647913061,0.0002817914937622845,0.00027872899954672903,0.00028091701096855104,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,finite-time/step,1.187509042210877e-06,6.250047590583563e-08,1.1250085663050413e-06,1.2500095181167126e-06,1.1250085663050413e-06,1.2295058695599437e-06,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,hitting-probability/cold-all-states,7.035399903543293e-05,1.3749959180131555e-06,6.942650361452252e-05,7.309373177122325e-05,6.96875067660585e-05,7.174999336712062e-05,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,hitting-time/cold-all-states,0.0001430209813406691,1.49996776599437e-06,0.00014163599553285167,0.00014649025251856074,0.00014200000441633165,0.0001441249914932996,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,hitting/bounded/at-most/k-10,6.127099914010614e-05,1.3750104699283838e-06,6.03442604187876e-05,6.282276444835588e-05,6.0542020946741104e-05,6.256251072045416e-05,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,hitting/bounded/at-most/k-100,0.0005094165098853409,6.93750916980207e-06,0.0005027394872740842,0.0005162917514098808,0.0005061508873041021,0.0005152499943505973,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,hitting/bounded/exact/k-10,5.864549893885851e-05,7.500057108700275e-07,5.784350651083514e-05,5.929174221819267e-05,5.816498814965599e-05,5.9250014601275325e-05,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,hitting/bounded/exact/k-100,0.0005066665034973994,9.375216905027628e-07,0.0005058017413830385,0.0005076872548670508,0.0005059589893789962,0.0005073960055597126,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,hitting/bounded/greater-than/k-10,6.247899727895856e-05,9.159994078800082e-07,6.165625381981954e-05,6.355248478939757e-05,6.202100485097617e-05,6.320900865830481e-05,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,hitting/bounded/greater-than/k-100,0.0005060209950897843,5.229507223702967e-06,0.0005027912411605939,0.0005176147606107406,0.0005034580099163577,0.0005140830180607736,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,power/10,0.0003917084977729246,4.683349106926471e-05,0.00034655226045288146,0.0005000629971618764,0.00036466600431595,0.0004674580122809857,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,power/100,0.00036072899820283055,5.417008651420474e-06,0.0003570105109247379,0.0003669064972200431,0.00035791698610410094,0.00036614600685425103,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,power/2,0.0003395829990040511,1.4579854905605316e-06,0.0003385627569514327,0.000341968763677869,0.00033862501732073724,0.0003411670040804893,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,return/bounded/k-10,6.247899727895856e-05,6.250193109735847e-07,6.18960038991645e-05,6.345874135149643e-05,6.220798240974545e-05,6.279200897552073e-05,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,return/bounded/k-100,0.0005267495143925771,8.458984666503966e-06,0.0005100624839542434,0.0005327392427716404,0.0005169375072000548,0.0005316250026226044,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,stationary,0.0001714584941510111,1.2499949662014842e-06,0.000170750507095363,0.00017404225945938379,0.00017097951786126941,0.00017304200446233153,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,structure/classes-cold,3.7437494029290974e-05,5.419860826805234e-07,3.704198752529919e-05,3.809375630225986e-05,3.7125006201677024e-05,3.7791993599967105e-05,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,structure/classes-lifecycle,0.0008966664900071919,4.812507540918887e-06,0.000893697993888054,0.0009031880035763606,0.000894041993888095,0.000899063001270406,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,structure/classes-warm/access,2.1938544959994032e-07,1.2521006283350314e-09,2.181270741857588e-07,2.2044685028959067e-07,2.181937001296319e-07,2.2019165044184774e-07,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,structure/classes-warm/consumed,1.7253187994356269e-06,8.822900417726454e-09,1.7205656251462642e-06,1.7622197759919799e-06,1.7223083006683738e-06,1.7469270998844878e-06,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,structure/cyclic-classes-cold,0.0008735000155866146,0.00017745849618222564,0.0006983332423260435,0.0011813954915851355,0.0007410209946101531,0.001005201561565627,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,structure/cyclic-classes-warm,2.41315415041754e-06,7.67395977163688e-08,2.3141500001656823e-06,2.479905276413774e-06,2.337602051557042e-06,2.469012548681349e-06,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,structure/irreducible-cold,3.5667006159201264e-05,3.9600126910954714e-07,3.5302255128044635e-05,3.612500586314127e-05,3.537499287631363e-05,3.599948831833899e-05,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,structure/irreducible-warm,2.3208960046758875e-07,3.8562502595596e-09,2.280896260344889e-07,2.3537815141025932e-07,2.2954375017434357e-07,2.3470415180781855e-07,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,structure/period-cold,0.0003480625164229423,2.5834888219833374e-06,0.00034684398997342214,0.0003522397528286092,0.0003470204679615563,0.00035112499608658254,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,structure/period-warm,2.4213124997913837e-07,4.570849705487485e-09,2.404312501312233e-07,2.5008852608152664e-07,2.408333515631966e-07,2.474145992891863e-07,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,visits/bounded-expectation/k-10,3.110448596999049e-05,3.1298259273171425e-07,3.080250462517142e-05,3.160449705319479e-05,3.0915992101654414e-05,3.13749915221706e-05,30 +pydtmc,periodic-n0025-s01729,periodic,25,1729,visits/bounded-expectation/k-100,9.47499938774854e-05,4.1701423469930887e-07,9.42707629292272e-05,9.503150067757815e-05,9.439550922252238e-05,9.495849371887743e-05,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,construction/public-consumed,0.0008239169983426109,6.749993190169334e-06,0.000819447755930014,0.0008326872484758496,0.000821249486762099,0.0008294374856632203,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,evolution/k-10,6.489599763881415e-05,5.829933797940612e-07,6.44999963697046e-05,6.568800017703325e-05,6.46044936729595e-05,6.552100239787251e-05,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,evolution/k-100,0.0002811250014929101,2.604501787573099e-06,0.0002784587413771078,0.00028347950137685984,0.00027902101282961667,0.0002827499993145466,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,evolution/one-step,4.258350236341357e-05,6.665068212896585e-07,4.2166997445747256e-05,4.3520987674128264e-05,4.227101453579962e-05,4.325000918470323e-05,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,finite-time/n-step/k-10,6.393798685166985e-05,1.0624935384839773e-06,6.323924026219174e-05,7.255276432260871e-05,6.337501690723002e-05,6.67289859848097e-05,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,finite-time/n-step/k-100,0.00027964598848484457,1.437496393918991e-06,0.00027919748390559107,0.0002813652536133304,0.0002794579922920093,0.0002810000005410984,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,finite-time/observation/k-10,6.391649367287755e-05,8.750066626816988e-07,6.314601341728121e-05,6.48752466076985e-05,6.343751738313586e-05,6.454097456298769e-05,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,finite-time/observation/k-100,0.0002789370046230033,1.6660051187500358e-06,0.0002772604930214584,0.00028041699988534674,0.0002773750020423904,0.0002798749919747934,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,finite-time/step,1.2920063454657793e-06,8.40227585285902e-08,1.207983586937189e-06,1.3750031939707696e-06,1.2085074558854103e-06,1.374981366097927e-06,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,hitting-probability/cold-all-states,7.162548718042672e-05,1.708496711216867e-06,7.01767421560362e-05,7.457299216184765e-05,7.04795093042776e-05,7.331300002988428e-05,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,hitting-time/cold-all-states,0.00014958300744183362,4.208501195535064e-06,0.00014651050878455862,0.00015399976109620184,0.00014835399633739144,0.0001532500027678907,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,hitting/bounded/at-most/k-10,6.050000956747681e-05,1.687512849457562e-06,5.92812430113554e-05,6.316698272712529e-05,5.9562502428889275e-05,6.3000014051795e-05,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,hitting/bounded/at-most/k-100,0.0005144579918123782,5.8124860515818e-06,0.0005108442419441417,0.0005213340045884252,0.0005112295038998127,0.0005197709979256615,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,hitting/bounded/exact/k-10,6.047899660188705e-05,8.329952834174037e-07,5.9458739997353405e-05,6.10524948569946e-05,5.9999991208314896e-05,6.091699469834566e-05,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,hitting/bounded/exact/k-100,0.0005281664925860241,8.208502549678087e-06,0.0004958852441632189,0.0005338857445167378,0.000509812991367653,0.0005322494980646297,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,hitting/bounded/greater-than/k-10,6.074999691918492e-05,9.585055522620678e-07,5.971849168417975e-05,6.119775207480416e-05,5.9896003222092986e-05,6.112499977461994e-05,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,hitting/bounded/greater-than/k-100,0.0005365620017983019,4.187488229945302e-06,0.0005109682460897602,0.0005389995058067143,0.0005186039925320074,0.0005386034899856895,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,power/10,0.0003437704872339964,2.020999090746045e-06,0.00034274976496817544,0.0003464479887043126,0.00034304099972359836,0.00034608348505571485,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,power/100,0.00035154201032128185,2.0630104700103402e-06,0.0003498024889267981,0.0003538235032465309,0.00035000000207219273,0.00035364598443266004,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,power/2,0.00034314600634388626,2.5619956431910396e-06,0.00034045825304929167,0.0003451252487138845,0.000341181271505775,0.0003449374926276505,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,return/bounded/k-10,6.156248855404556e-05,9.374925866723061e-07,6.051051605027169e-05,6.237500929273665e-05,6.0791513533331454e-05,6.231249426491559e-05,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,return/bounded/k-100,0.0005138539854669943,1.2541975593194366e-05,0.0005021352553740144,0.0005265520012471825,0.0005075829976703972,0.0005214164993958548,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,stationary,0.00017481250688433647,1.3334938557818532e-06,0.0001735105033731088,0.0001761459934641607,0.00017368749831803143,0.00017564599693287164,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,structure/classes-cold,3.706249117385596e-05,8.124770829454064e-07,3.6260506021790206e-05,3.81145000574179e-05,3.662498784251511e-05,3.7478996091522276e-05,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,structure/classes-lifecycle,0.0008909374882932752,4.7079811338335276e-06,0.0008859067602315918,0.0008930935000535101,0.0008883544942364097,0.0008925000001909211,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,structure/classes-warm/access,2.3754580033710224e-07,2.381298691034329e-09,2.2346772529999727e-07,2.3911149983177896e-07,2.3053545155562462e-07,2.3817079927539453e-07,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,structure/classes-warm/consumed,1.7143041492090562e-06,6.952049443498418e-09,1.7093073241994716e-06,1.7301125255471562e-06,1.7097499992814846e-06,1.7288250004639849e-06,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,structure/cyclic-classes-cold,0.0006838130066171288,3.979497705586255e-06,0.0006800935007049702,0.0006876459956401959,0.0006810624909121543,0.0006866454932605848,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,structure/cyclic-classes-warm,2.2633999993558973e-06,3.2604497391730737e-09,2.2608260245760904e-06,2.275138549157418e-06,2.261306199943647e-06,2.269674165509059e-06,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,structure/irreducible-cold,3.6083481973037124e-05,5.839829100295901e-07,3.56250093318522e-05,3.69795088772662e-05,3.568750980775803e-05,3.660449874587357e-05,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,structure/irreducible-warm,2.217499990365468e-07,1.1916999937966603e-09,2.209260499512311e-07,2.2381767485057935e-07,2.2116040054243058e-07,2.233604493085295e-07,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,structure/period-cold,0.0003472914977464825,3.875000402331352e-06,0.0003438542553340085,0.00035131225013174117,0.0003448330098763108,0.00034927048545796424,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,structure/period-warm,2.268395503051579e-07,1.6874997527338585e-09,2.243761016870849e-07,2.2813335017417556e-07,2.254041493870318e-07,2.2749375057173893e-07,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,visits/bounded-expectation/k-10,3.1917006708681583e-05,7.915077731013298e-07,3.144726360915229e-05,3.769750037463382e-05,3.156250750180334e-05,3.5129167736158685e-05,30 +pydtmc,periodic-n0025-s02718,periodic,25,2718,visits/bounded-expectation/k-100,9.427098848391324e-05,6.250047590583563e-07,9.38852463150397e-05,9.494774712948129e-05,9.40830068429932e-05,9.485399641562253e-05,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,construction/public-consumed,0.0009534795099170879,0.0001185209839604795,0.0008662085092510097,0.0012775097347912379,0.0008798119961284101,0.0012179375044070184,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,evolution/k-10,6.939600280020386e-05,3.999492037110031e-06,6.626025424338877e-05,7.556250056950375e-05,6.672900053672493e-05,7.402099436149001e-05,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,evolution/k-100,0.00028950000705663115,8.874994819052517e-06,0.0002842085013980977,0.0003010520013049245,0.00028708300669677556,0.00029837500187568367,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,evolution/one-step,4.4082989916205406e-05,1.7294951248914003e-06,4.260400601197034e-05,4.714573879027739e-05,4.287451156415045e-05,4.6146000386215746e-05,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,finite-time/n-step/k-10,6.520850001834333e-05,1.3750104699283838e-06,6.408299668692052e-05,6.894800026202574e-05,6.414549716282636e-05,6.589600525330752e-05,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,finite-time/n-step/k-100,0.00027893800870515406,2.3539905669167638e-06,0.0002776145120151341,0.00028278174431761727,0.00027804150886368006,0.0002811250014929101,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,finite-time/observation/k-10,6.67289859848097e-05,1.9165017874911427e-06,6.494799890788272e-05,6.864550232421607e-05,6.53750030323863e-05,6.820799899287522e-05,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,finite-time/observation/k-100,0.00028133300656918436,5.083988071419299e-06,0.00027818724629469216,0.00028658349765464664,0.00027972899260930717,0.00028529200062621385,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,finite-time/step,1.3124954421073198e-06,1.0451185517013073e-07,1.2080126907676458e-06,1.4170072972774506e-06,1.2289965525269508e-06,1.3959943316876888e-06,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,hitting-probability/cold-all-states,7.068800914566964e-05,1.5004916349425912e-06,6.948925147298723e-05,7.282275328179821e-05,6.989548273850232e-05,7.164599082898349e-05,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,hitting-time/cold-all-states,0.00014412449672818184,2.2915046429261565e-06,0.00014257325528888032,0.0001471147406846285,0.00014289599494077265,0.00014625000767409801,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,hitting/bounded/at-most/k-10,6.166700040921569e-05,2.3335014702752233e-06,6.0729740653187037e-05,6.900000153109431e-05,6.0937003581784666e-05,6.631251017097384e-05,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,hitting/bounded/at-most/k-100,0.000525770490639843,7.895490853115916e-06,0.0005183332395972684,0.0005454267447930761,0.000521208014106378,0.0005376045010052621,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,hitting/bounded/exact/k-10,6.064648914616555e-05,1.9794824765995145e-06,5.9426514781080186e-05,6.336474325507879e-05,5.991649231873453e-05,6.135449802968651e-05,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,hitting/bounded/exact/k-100,0.0005450210010167211,7.520997314713895e-06,0.0005384370015235618,0.0005595622496912256,0.0005393339961301535,0.0005496874946402386,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,hitting/bounded/greater-than/k-10,6.579200271517038e-05,4.375498974695802e-06,6.31560105830431e-05,8.52189987199381e-05,6.37500052107498e-05,7.754151010885835e-05,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,hitting/bounded/greater-than/k-100,0.0005344579985830933,2.3833985324017704e-05,0.000510999518155586,0.0005573129892582074,0.000517082997248508,0.0005551250069402158,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,power/10,0.00036556299892254174,1.3209006283432245e-05,0.00035398974432609975,0.00039361448580166325,0.0003581039927667007,0.0003802499995799735,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,power/100,0.00035464600659906864,3.2504904083907604e-06,0.0003526562504703179,0.0003628435079008341,0.0003532504924805835,0.00035960400418844074,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,power/2,0.0003511460090521723,6.833492079749703e-06,0.0003440002692514099,0.00035649949131766334,0.00034493750717956573,0.0003532289993017912,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,return/bounded/k-10,6.410448986571282e-05,2.9174843803048134e-06,6.221850344445556e-05,6.840649439254776e-05,6.239599315449595e-05,6.760400719940662e-05,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,return/bounded/k-100,0.000517979497089982,3.332985215820372e-06,0.0005148747441126034,0.0005223127373028547,0.0005161460139788687,0.0005208960064919665,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,stationary,0.00017122899589594454,9.170034900307655e-07,0.00017043775733327493,0.00017263599875150248,0.00017058300727512687,0.0001720000000204891,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,structure/classes-cold,3.9416016079485416e-05,1.6035191947594285e-06,3.800999547820538e-05,4.1926999983843416e-05,3.8604484871029854e-05,4.052050644531846e-05,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,structure/classes-lifecycle,0.0009300209931097925,3.3271004213020205e-05,0.0009105519930017181,0.0009843337393249385,0.0009207084949593991,0.0009673125023255125,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,structure/classes-warm/access,2.245729017886333e-07,4.541600355878464e-09,2.202375493652653e-07,2.300698011822533e-07,2.206621884033666e-07,2.2677500091958793e-07,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,structure/classes-warm/consumed,1.7613146002986469e-06,2.0150050113443336e-08,1.7527885262097699e-06,1.8088802258716896e-06,1.7538499494548887e-06,1.8052604005788452e-06,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,structure/cyclic-classes-cold,0.0006842919974587858,5.437512299977243e-06,0.0006791982668801211,0.0006897815110278316,0.0006802499992772937,0.0006892500096000731,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,structure/cyclic-classes-warm,2.3235479005961676e-06,4.886040114797613e-08,2.274181249231333e-06,2.364803099044366e-06,2.2854332986753432e-06,2.3570125020341946e-06,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,structure/irreducible-cold,3.63959843525663e-05,9.164941729977727e-07,3.567750536603853e-05,3.747924347408116e-05,3.575001028366387e-05,3.689651202876121e-05,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,structure/irreducible-warm,2.236021013231948e-07,7.646012818440879e-10,2.2159374930197374e-07,2.2421770190703682e-07,2.229937497759238e-07,2.239321901652147e-07,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,structure/period-cold,0.00035029200080316514,3.667009877972305e-06,0.00034658348886296153,0.000353104253008496,0.0003471460076980293,0.0003514160052873194,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,structure/period-warm,2.2824374900665136e-07,2.341700019314898e-09,2.259343753394205e-07,2.3138640099205076e-07,2.2615420166403057e-07,2.3008540010778233e-07,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,visits/bounded-expectation/k-10,3.1541509088128805e-05,3.745080903172493e-07,3.117750020464882e-05,3.2125004508998245e-05,3.1270988984033465e-05,3.1853982363827527e-05,30 +pydtmc,periodic-n0025-s31415,periodic,25,31415,visits/bounded-expectation/k-100,9.458400018047541e-05,4.789908416569233e-07,9.434426465304568e-05,9.519774903310463e-05,9.443701128475368e-05,9.508398943580687e-05,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,construction/public-consumed,0.0024590414977865294,2.5874978746287525e-05,0.002443218261760194,0.0024921565054683015,0.0024452710058540106,0.002490145488991402,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,evolution/k-10,8.785400132182986e-05,9.585055522620678e-07,8.683299529366195e-05,8.827124838717282e-05,8.695847864146345e-05,8.816650370135903e-05,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,evolution/k-100,0.00031841649615671486,2.4170003598555923e-06,0.00031648949516238645,0.00032091674802359194,0.0003168130060657859,0.00032020955804910043,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,evolution/one-step,6.33544841548428e-05,1.0210060281679034e-06,6.235374166863039e-05,6.425999890780076e-05,6.26669789198786e-05,6.393749208655208e-05,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,finite-time/n-step/k-10,8.564551535528153e-05,8.960050763562322e-07,8.455200440948829e-05,8.618724677944556e-05,8.479200187139213e-05,8.595801773481071e-05,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,finite-time/n-step/k-100,0.0003192290023434907,1.0410003596916795e-06,0.00031849976221565157,0.0003207712506991811,0.000318895501550287,0.00032022950472310185,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,finite-time/observation/k-10,8.556248212698847e-05,8.539791451767087e-07,8.476050425088033e-05,8.648976654512808e-05,8.487500599585474e-05,8.612449164502323e-05,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,finite-time/observation/k-100,0.00032131299667526037,2.874512574635446e-06,0.0003188017653883435,0.00032503150578122586,0.000319437516736798,0.0003239999932702631,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,finite-time/step,1.4580145943909883e-06,6.250047590583563e-08,1.385255018249154e-06,1.500004145782441e-06,1.4169781934469938e-06,1.4590041246265173e-06,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,hitting-probability/cold-all-states,0.00016500000492669642,1.5830155462026596e-06,0.00016411499382229522,0.00016685349692124873,0.00016431249969173223,0.0001661669957684353,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,hitting-time/cold-all-states,0.00034591650182846934,2.437504008412361e-06,0.0003444270041654818,0.0003491454917821102,0.0003448335046414286,0.0003486250061541796,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,hitting/bounded/at-most/k-10,8.612501551397145e-05,9.790092008188367e-07,8.554173109587282e-05,8.729100227355957e-05,8.568799239583313e-05,8.720799814909697e-05,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,hitting/bounded/at-most/k-100,0.0007838540041120723,1.179150422103703e-05,0.0007699897323618643,0.0007934682507766411,0.0007780624873703346,0.0007919170020613819,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,hitting/bounded/exact/k-10,8.552049985155463e-05,6.87985448166728e-07,8.468799933325499e-05,8.611449447926134e-05,8.516649540979415e-05,8.591701043769717e-05,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,hitting/bounded/exact/k-100,0.0007802290056133643,5.624489858746529e-06,0.0007752502424409613,0.0007866152591304854,0.0007760620064800605,0.0007846664957469329,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,hitting/bounded/greater-than/k-10,8.606250048615038e-05,6.67001586407423e-07,8.546850585844368e-05,8.716701267985627e-05,8.550001075491309e-05,8.660501334816216e-05,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,hitting/bounded/greater-than/k-100,0.0007834165007807314,6.125497748143971e-06,0.0007753442405373789,0.0007890314882388338,0.0007773539982736111,0.0007869789988035336,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,power/10,0.0005372500017983839,2.164600300602615e-05,0.0005174787438591011,0.0005591457593254745,0.000525708994246088,0.0005459375097416341,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,power/100,0.0005164585018064827,4.0829909266904e-06,0.0005120932546560653,0.0005194687473704107,0.00051329200505279,0.0005185835034353659,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,power/2,0.0005198960134293884,2.3124506697058678e-05,0.0004965527623426169,0.0005409165169112384,0.0004987894124496961,0.0005290005065035075,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,return/bounded/k-10,8.504150900989771e-05,8.329952834174037e-07,8.446924039162695e-05,8.597924170317128e-05,8.45834754727548e-05,8.585450996179134e-05,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,return/bounded/k-100,0.0007788330112816766,4.47950151283294e-06,0.0007740107321296819,0.0007826664950698614,0.000776020999182947,0.0007813545089447871,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,stationary,0.00040214549517259,2.45800765696913e-06,0.0003999377368018031,0.0004045414971187711,0.0004006045055575669,0.00040314548823516816,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,structure/classes-cold,7.239550177473575e-05,9.164941729977727e-07,7.121851376723498e-05,7.288574852282181e-05,7.141650712583214e-05,7.266650209203362e-05,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,structure/classes-lifecycle,0.0025800419825827703,9.791998309083283e-06,0.0025735207527759485,0.0025920522602973506,0.002574958503828384,0.0025880419998429716,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,structure/classes-warm/access,2.1814585052197798e-07,4.2499887058510684e-10,2.1772190084448084e-07,2.1855314917047506e-07,2.178145485231653e-07,2.1843750146217644e-07,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,structure/classes-warm/consumed,3.0259041493991387e-06,1.1931199696845995e-08,3.017130225634901e-06,3.0471593738184313e-06,3.018243749102112e-06,3.0454874999122693e-06,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,structure/cyclic-classes-cold,0.0017269170057261363,7.853988790884614e-06,0.0017197502456838265,0.0017349064946756698,0.0017205619951710105,0.0017331874987576157,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,structure/cyclic-classes-warm,4.140345798805356e-06,9.879151184577344e-09,4.1244916516006924e-06,4.144638524303445e-06,4.1276521005784165e-06,4.144154148525558e-06,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,structure/irreducible-cold,6.912500248290598e-05,6.875052349641919e-07,6.8583496613428e-05,7.00519813108258e-05,6.885400216560811e-05,6.981247861403972e-05,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,structure/irreducible-warm,2.2395835112547502e-07,1.487550616729998e-09,2.2274582370300777e-07,2.2559897406608796e-07,2.2340620053000746e-07,2.2508749971166252e-07,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,structure/period-cold,0.0009387295140186325,4.728994099423289e-06,0.0009259792495868169,0.0009413542356924154,0.0009324590064352378,0.0009400419949088246,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,structure/period-warm,2.2747290058759972e-07,4.0839950088410987e-10,2.2703017457388341e-07,2.2785734981880523e-07,2.2729374904884025e-07,2.2770414943806826e-07,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,visits/bounded-expectation/k-10,5.1520997658371925e-05,6.665068212896585e-07,5.093774962006137e-05,5.219825834501535e-05,5.116700776852667e-05,5.197949940338731e-05,30 +pydtmc,periodic-n0050-s01729,periodic,50,1729,visits/bounded-expectation/k-100,0.00012929149670526385,1.2290111044421792e-06,0.0001285207472392358,0.00013209400640334934,0.00012877049448434263,0.00013093749294057488,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,construction/public-consumed,0.0024454789963783696,1.1895986972376704e-05,0.0024374374916078523,0.0024600212564109825,0.002440041513182223,0.00245585449738428,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,evolution/k-10,8.718798926565796e-05,5.004985723644495e-07,8.677076402818784e-05,8.842750685289502e-05,8.685400825925171e-05,8.762499783188105e-05,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,evolution/k-100,0.00032054149778559804,1.3335084076970816e-06,0.0003194160162820481,0.0003219585050828755,0.00031985399255063385,0.00032179150730371475,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,evolution/one-step,6.322951230686158e-05,9.375071385875344e-07,6.227100675459951e-05,6.379174010362476e-05,6.258301436901093e-05,6.366650632116944e-05,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,finite-time/n-step/k-10,8.606248593423516e-05,8.960050763562322e-07,8.513525972375646e-05,8.678173617227003e-05,8.525048906449229e-05,8.650000199850183e-05,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,finite-time/n-step/k-100,0.0003175625024596229,2.020999090746045e-06,0.00031591649167239666,0.0003200624923920259,0.00031627051066607237,0.0003184590023010969,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,finite-time/observation/k-10,8.556201646570116e-05,9.375071385875344e-07,8.459375385427848e-05,8.631251694168895e-05,8.495849033351988e-05,8.608349889982492e-05,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,finite-time/observation/k-100,0.0003187500115018338,1.6869889805093408e-06,0.000317062993417494,0.00032023924723034725,0.00031754199881106615,0.00031974949524737895,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,finite-time/step,1.4170072972774506e-06,6.2515027821064e-08,1.3750104699283838e-06,1.5307668945752084e-06,1.3955141184851527e-06,1.4790130080655217e-06,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,hitting-probability/cold-all-states,0.00016424950445070863,9.995128493756056e-07,0.0001634792424738407,0.00016706274618627504,0.00016385399794671685,0.00016529200365766883,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,hitting-time/cold-all-states,0.00034929151297546923,3.604029188863933e-06,0.0003468119975877926,0.00035494827170623466,0.00034712449996732175,0.000352541494066827,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,hitting/bounded/at-most/k-10,8.668750524520874e-05,7.715134415775537e-07,8.612498641014099e-05,8.756301394896582e-05,8.614601392764598e-05,8.731302223168314e-05,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,hitting/bounded/at-most/k-100,0.0007862704951548949,6.728994776494801e-06,0.0007758647479931824,0.0007920205098344013,0.0007805204950273037,0.0007900414930190891,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,hitting/bounded/exact/k-10,8.516650996170938e-05,6.664922693744302e-07,8.455225179204717e-05,8.58227358548902e-05,8.462500409223139e-05,8.56455008033663e-05,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,hitting/bounded/exact/k-100,0.0007867289968999103,4.0829909266904e-06,0.0007828647649148479,0.0007907392500783317,0.0007841250044293702,0.0007902709912741557,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,hitting/bounded/greater-than/k-10,8.672950207255781e-05,7.704948075115681e-07,8.590625657234341e-05,8.743724902160466e-05,8.606248593423516e-05,8.735399751458317e-05,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,hitting/bounded/greater-than/k-100,0.0007758330029901117,7.937996997497976e-06,0.0007704482341068797,0.0007898644980741665,0.0007727079791948199,0.000785771495429799,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,power/10,0.0005024790007155389,2.0834995666518807e-06,0.0005001252648071386,0.0005037502414779738,0.0005008754960726947,0.0005035415088059381,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,power/100,0.0005149795033503324,2.9999937396496534e-06,0.0005125627503730357,0.0005186042471905239,0.000512917002197355,0.0005166454939171672,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,power/2,0.0004936045006616041,2.270506229251623e-06,0.0004913652592222206,0.0004963857427355833,0.0004925209941575304,0.0004950414877384901,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,return/bounded/k-10,8.547899778932333e-05,5.415058694779873e-07,8.516700472682714e-05,8.64372486830689e-05,8.524997974745929e-05,8.604151662439108e-05,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,return/bounded/k-100,0.0007708540069870651,5.437497748062015e-06,0.0007661145136808045,0.0007805312634445727,0.0007674160005990416,0.0007770624797558412,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,stationary,0.00040699998498894274,5.333495209924877e-06,0.0003987187519669533,0.00041203099681297317,0.0004054790042573586,0.0004099590005353093,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,structure/classes-cold,7.343750621657819e-05,2.291490091010928e-06,7.188549352576956e-05,8.695799624547362e-05,7.208350871223956e-05,8.127048204187304e-05,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,structure/classes-lifecycle,0.002689854009076953,6.925000343471766e-05,0.002611738978885114,0.0027296565094729885,0.0026170625060331076,0.0027087500056950375,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,structure/classes-warm/access,2.1756880014436318e-07,3.3324904507027607e-10,2.1706977495341563e-07,2.1781977484351956e-07,2.173166983993724e-07,2.1780419920105488e-07,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,structure/classes-warm/consumed,3.0101187498075887e-06,3.85834864573554e-09,3.005807324370835e-06,3.0128458740364296e-06,3.0065812505199576e-06,3.011985378943791e-06,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,structure/cyclic-classes-cold,0.0017195624968735501,7.145499694161117e-06,0.0017117184979724698,0.0017259374872082844,0.0017128960025729612,0.001723666995530948,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,structure/cyclic-classes-warm,4.155362449819222e-06,4.614549106918081e-09,4.150347950780997e-06,4.157956276321784e-06,4.151293748873286e-06,4.157062550075352e-06,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,structure/irreducible-cold,6.931250391062349e-05,5.83502696827054e-07,6.90102533553727e-05,7.007350359344855e-05,6.910447409609332e-05,6.966700311750174e-05,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,structure/irreducible-warm,2.220291498815641e-07,6.937509169802125e-10,2.213978732470423e-07,2.227301745733712e-07,2.215729487943463e-07,2.226250508101657e-07,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,structure/period-cold,0.0009411454957444221,9.520997991785407e-06,0.0009328127489425242,0.0009631145003368147,0.0009347080049337819,0.0009543955093249679,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,structure/period-warm,2.2692079946864396e-07,8.833507308736491e-10,2.2594479960389435e-07,2.2734477461199277e-07,2.262239046103787e-07,2.2724790032953026e-07,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,visits/bounded-expectation/k-10,5.1625509513542056e-05,4.3700856622308493e-07,5.121922731632367e-05,5.2051742386538535e-05,5.129148485139012e-05,5.185400368645787e-05,30 +pydtmc,periodic-n0050-s02718,periodic,50,2718,visits/bounded-expectation/k-100,0.0001305625046370551,1.5834957594051957e-06,0.00012932274694321677,0.00013262526772450656,0.0001297295093536377,0.00013187500007916242,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,construction/public-consumed,0.002473311993526295,1.3000491890124977e-05,0.002458999981172383,0.00248552075936459,0.002463917015120387,0.0024807914887787774,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,evolution/k-10,8.687499212101102e-05,6.664777174592018e-07,8.645799243822694e-05,8.823950338410214e-05,8.654099656268954e-05,8.779202471487224e-05,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,evolution/k-100,0.0003201875078957528,1.5625118976458907e-06,0.00031882298208074644,0.0003220000071451068,0.0003191249998053536,0.00032145899604074657,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,evolution/one-step,6.295848288573325e-05,6.664777174592018e-07,6.262498209252954e-05,6.420797581085935e-05,6.266700802370906e-05,6.383299478329718e-05,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,finite-time/n-step/k-10,8.550001075491309e-05,7.289927452802658e-07,8.492698543705046e-05,8.657249418320134e-05,8.510448969900608e-05,8.614705257059539e-05,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,finite-time/n-step/k-100,0.0003177085018251091,1.8540158635005355e-06,0.0003153750076307915,0.0003191350115230307,0.0003162684053677367,0.00031860399758443236,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,finite-time/observation/k-10,8.583349699620157e-05,6.665068212896585e-07,8.55515172588639e-05,8.672948752064258e-05,8.566700853407383e-05,8.64790054038167e-05,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,finite-time/observation/k-100,0.00031641700479667634,8.540082490071654e-07,0.0003161249915137887,0.00031761475111125037,0.00031620849040336907,0.00031739599944557995,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,finite-time/step,1.4794932212680578e-06,6.349000614136457e-08,1.415995939169079e-06,1.5417608665302396e-06,1.4169927453622222e-06,1.5205005183815956e-06,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,hitting-probability/cold-all-states,0.00016464600048493594,1.250504283234477e-06,0.000164052500622347,0.00016751050134189427,0.00016414548736065626,0.00016672900528647006,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,hitting-time/cold-all-states,0.00034635399060789496,2.625005436129868e-06,0.0003445515103521757,0.00034984324884135276,0.00034518749453127384,0.00034925049112644047,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,hitting/bounded/at-most/k-10,8.645850175525993e-05,1.353997504338622e-06,8.566650649299845e-05,0.0001197500096168369,8.581300789956003e-05,0.00010302050213795155,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,hitting/bounded/at-most/k-100,0.0007794584962539375,6.750502507202327e-06,0.0007728744822088629,0.0007866252490202896,0.0007750210061203688,0.000785416501457803,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,hitting/bounded/exact/k-10,8.47704941406846e-05,8.755159797146916e-07,8.437498036073521e-05,8.609373617218807e-05,8.445800631307065e-05,8.583349699620157e-05,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,hitting/bounded/exact/k-100,0.0007734165119472891,5.1040115067735314e-06,0.0007687392353545874,0.0007788860166328959,0.0007699164998484775,0.0007780204905429855,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,hitting/bounded/greater-than/k-10,8.733299910090864e-05,1.874504960142076e-06,8.651001553516835e-05,9.306300489697605e-05,8.672900730744004e-05,9.08330111997202e-05,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,hitting/bounded/greater-than/k-100,0.0007848119857953861,4.22849552705884e-06,0.00077927099482622,0.0007887710016802885,0.000781083494075574,0.0007886255043558776,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,power/10,0.0004997084906790406,1.708496711216867e-06,0.0004979789882781915,0.0005006352512282319,0.0004982489605026786,0.0005002505058655515,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,power/100,0.0005114994855830446,1.9164872355759144e-06,0.0005100102571304888,0.0005140207649674267,0.0005107699802465504,0.0005126250034663826,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,power/2,0.0004907080001430586,1.5834957594051957e-06,0.0004890312702627853,0.0004914687597192824,0.0004894790035905316,0.0004912919976050034,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,return/bounded/k-10,8.66670161485672e-05,1.7085112631320953e-06,8.539576083421707e-05,9.406201570527628e-05,8.56254919199273e-05,8.837500354275107e-05,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,return/bounded/k-100,0.0007755414990242571,3.083507181145251e-06,0.0007724164970568381,0.0007783749897498637,0.0007733329985057935,0.0007771249947836623,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,stationary,0.0004074789903825149,4.3330073822289705e-06,0.00040339576662518084,0.0004120517478440888,0.0004049374983878806,0.00041129150486085564,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,structure/classes-cold,7.21454998711124e-05,7.500057108700275e-07,7.159349479479715e-05,7.291699876077473e-05,7.168749289121479e-05,7.281250145751983e-05,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,structure/classes-lifecycle,0.002544708491768688,1.518749922979623e-05,0.0025307809992227703,0.002561405759479385,0.0025401869777851973,0.00255687499884516,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,structure/classes-warm/access,2.1625414956361054e-07,1.05629878817124e-09,2.1584889982477763e-07,2.1762712567579001e-07,2.1595419966615738e-07,2.1755419729743153e-07,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,structure/classes-warm/consumed,3.0033042014110833e-06,1.3479497283698453e-09,3.00216140167322e-06,3.0046343759750017e-06,3.0027291504666213e-06,3.0040229481528515e-06,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,structure/cyclic-classes-cold,0.0017405210091965273,1.529201108496636e-05,0.0017294902572757564,0.001886770493001677,0.0017337294848402962,0.001820645498810336,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,structure/cyclic-classes-warm,4.126158299914095e-06,1.0208299499935846e-08,4.122330175596289e-06,4.145928075013216e-06,4.123802100366447e-06,4.143031199055258e-06,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,structure/irreducible-cold,6.964549538679421e-05,7.289927452802658e-07,6.8323002778925e-05,7.031226414255798e-05,6.918750295881182e-05,7.004149665590376e-05,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,structure/irreducible-warm,2.2105624957475812e-07,4.229485057294384e-10,2.2067182653700003e-07,2.214979009295348e-07,2.2090189395385096e-07,2.2127704869490116e-07,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,structure/period-cold,0.0009328330052085221,8.270988473668694e-06,0.0009236665136995725,0.0009407390098203905,0.000927166998735629,0.0009399995033163577,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,structure/period-warm,2.3235630069393663e-07,4.912550502922366e-09,2.2733744990546256e-07,2.3528957390226423e-07,2.295750004122965e-07,2.3324170033447443e-07,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,visits/bounded-expectation/k-10,5.162500019650906e-05,3.13011696562171e-07,5.133323429618031e-05,5.200999294174835e-05,5.133400554768741e-05,5.1875016652047634e-05,30 +pydtmc,periodic-n0050-s31415,periodic,50,31415,visits/bounded-expectation/k-100,0.00012910450459457934,7.289927452802658e-07,0.00012841675925301388,0.00012978100130567327,0.00012854201486334205,0.00012943749607075006,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,construction/public-consumed,0.009018687502248213,0.00012372950732242316,0.008905697752197739,0.009190801996737719,0.008954373122105608,0.009116291505051777,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,evolution/k-10,0.00013610449968837202,1.124994014389813e-06,0.00013544825924327597,0.0001377497537760064,0.00013583349937107414,0.00013720800052396953,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,evolution/k-100,0.000438166520325467,4.312532837502658e-06,0.000435250265581999,0.0004468022452783771,0.0004363330081105232,0.00044391598203219473,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,evolution/one-step,0.00010575000487733632,7.295020623132586e-07,0.00010508299601497129,0.00010679175466066226,0.0001052290026564151,0.00010631249460857362,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,finite-time/n-step/k-10,0.0001344164920737967,1.4579854905605316e-06,0.00013302099250722677,0.00013605176354758441,0.00013329149805940688,0.00013527308437915052,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,finite-time/n-step/k-100,0.0004336660203989595,3.041030140593648e-06,0.0004312087403377518,0.00043786399328382686,0.0004321249871281907,0.00043579100747592747,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,finite-time/observation/k-10,0.0001349580124951899,1.5625118976458907e-06,0.00013348900392884389,0.0001368020020890981,0.0001340000017080456,0.00013575000048149377,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,finite-time/observation/k-100,0.0004337295104051009,2.853994374163449e-06,0.00043230225128354505,0.00043946850928477943,0.0004334569362981711,0.0004374584968900308,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,finite-time/step,2.666492946445942e-06,8.348433766514063e-08,2.583990863058716e-06,2.7500136638991535e-06,2.6249908842146397e-06,2.7080095605924726e-06,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,hitting-probability/cold-all-states,0.0006423545128200203,2.5630142772570252e-06,0.0006399997582775541,0.0006456772462115623,0.0006408539920812473,0.0006445415056077763,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,hitting-time/cold-all-states,0.0013489169941749424,3.6669953260570765e-06,0.0013457912573358044,0.001353228981315624,0.0013471665006363764,0.0013513544836314395,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,hitting/bounded/at-most/k-10,0.00017697899602353573,1.083506504073739e-06,0.000175551998836454,0.00017781226051738486,0.00017614600074011832,0.00017722950724419206,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,hitting/bounded/at-most/k-100,0.0017078545060940087,4.687492037191987e-06,0.0017038747464539483,0.0017139894916908816,0.0017049375019269064,0.0017120414995588362,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,hitting/bounded/exact/k-10,0.00017506298900116235,1.0625080903992057e-06,0.00017391698202118278,0.0001760727318469435,0.00017425000260118395,0.00017585449677426368,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,hitting/bounded/exact/k-100,0.0017024584958562627,6.9999805418774486e-06,0.0016954475140664726,0.0017091872286982834,0.0016973540041362867,0.001707561983494088,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,hitting/bounded/greater-than/k-10,0.0001777500001480803,1.0834919521585107e-06,0.0001766247587511316,0.00017860451043816283,0.00017681250756140798,0.0001781665050657466,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,hitting/bounded/greater-than/k-100,0.0016986460104817525,3.457971615716815e-06,0.0016961354922386818,0.001705250258964952,0.0016967914998531342,0.0017027494905050844,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,power/10,0.001116416504373774,1.187509042210877e-06,0.0011153439918416552,0.0011176564876222983,0.001115708495490253,0.0011172100566909646,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,power/100,0.0011565835011424497,1.8544960767030716e-06,0.0011546560053830035,0.001158208746346645,0.0011560625134734437,0.0011578955018194392,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,power/2,0.0010947500122711062,8.74951365403831e-06,0.0010846252625924535,0.0010998329962603748,0.001086000498617068,0.0010979375074384734,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,return/bounded/k-10,0.00017497899534646422,8.755014277994633e-07,0.00017457324429415166,0.000176541754626669,0.00017485399439465255,0.00017591699725016952,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,return/bounded/k-100,0.0016943750088103116,5.437992513179779e-06,0.0016896660017664544,0.0016996772392303683,0.0016920829948503524,0.0016977290069917217,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,stationary,0.00113347900332883,1.5562516637146473e-05,0.0011225312409806065,0.0011772185025620274,0.0011257909936830401,0.001164042012533173,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,structure/classes-cold,0.0001598959934199229,1.311986125074327e-06,0.0001588019949849695,0.00016264625446638092,0.00015922899183351547,0.00016131199663504958,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,structure/classes-lifecycle,0.00914216649834998,3.650000144261867e-05,0.009115719258261379,0.009179645749100018,0.009119729496887885,0.00917325000045821,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,structure/classes-warm/access,2.1919170103501528e-07,7.562499376945102e-10,2.176208254240919e-07,2.1972285030642523e-07,2.1839170076418668e-07,2.1941879967926068e-07,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,structure/classes-warm/consumed,5.933237500721589e-06,1.8618959875311708e-07,5.6175197743868916e-06,6.015440648479853e-06,5.656887502118479e-06,5.991335400904063e-06,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,structure/cyclic-classes-cold,0.005123874987475574,9.749986929818988e-06,0.005115186984767206,0.005138124746736139,0.005118125001899898,0.005133041006047279,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,structure/cyclic-classes-warm,7.94252709893044e-06,2.6010401779786345e-08,7.906564575387165e-06,7.961550000618444e-06,7.921366651135032e-06,7.958412500738632e-06,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,structure/irreducible-cold,0.00015462450392078608,1.3325043255463243e-06,0.00015354224888142198,0.00015607275418005884,0.00015389600594062358,0.00015564651403110474,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,structure/irreducible-warm,2.2567289997823535e-07,1.114601036533698e-09,2.2425937495427206e-07,2.2612599932472222e-07,2.2445204958785325e-07,2.2604374971706418e-07,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,structure/period-cold,0.003086500000790693,1.6146499547176063e-05,0.00307608324510511,0.0031033027480589226,0.0030794790072832257,0.003095083506195806,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,structure/period-warm,2.313292003236711e-07,2.2625012206844966e-09,2.288874995429069e-07,2.3249162622960287e-07,2.2906039957888424e-07,2.3198749986477197e-07,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,visits/bounded-expectation/k-10,9.445799514651299e-05,4.790053935721517e-07,9.402073919773102e-05,9.507300273980945e-05,9.412498911842704e-05,9.47914959397167e-05,30 +pydtmc,periodic-n0100-s01729,periodic,100,1729,visits/bounded-expectation/k-100,0.00022256249212659895,6.460031727328897e-07,0.0002219692469225265,0.00022322926088236272,0.0002221670001745224,0.0002231250109616667,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,construction/public-consumed,0.008945249996031635,3.858350100927055e-05,0.008907853516575415,0.0089829477656167,0.00891029101330787,0.008972665993496776,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,evolution/k-10,0.00013643749116454273,1.2499949662014842e-06,0.00013553125609178096,0.0001391037367284298,0.00013581248640548438,0.00013797899009659886,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,evolution/k-100,0.00043485448986757547,3.145993105135858e-06,0.0004330314986873418,0.0004384477433632128,0.0004334370169090107,0.00043691700557246804,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,evolution/one-step,0.00010939600178971887,3.4580007195472717e-06,0.00010608401498757303,0.0001136352657340467,0.00010670798656065017,0.00011141649156343192,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,finite-time/n-step/k-10,0.00013420850154943764,9.164941729977727e-07,0.00013342699821805581,0.00013555250188801438,0.00013360449520405382,0.00013497898180503398,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,finite-time/n-step/k-100,0.00043924999772571027,4.624977009370923e-06,0.0004350207673269324,0.0004439997355802916,0.000436687987530604,0.00044160764045955144,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,finite-time/observation/k-10,0.00013452050916384906,1.4375109458342195e-06,0.0001331352468696423,0.00013595876225735992,0.00013337450218386948,0.00013556198973674327,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,finite-time/observation/k-100,0.0004365625063655898,3.125009243376553e-06,0.00043308400199748576,0.0004384792482596822,0.0004334579862188548,0.00043781305321317633,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,finite-time/step,2.6875059120357037e-06,1.6650301404297352e-07,2.6249908842146397e-06,4.572757461573929e-06,2.6249908842146397e-06,3.750524410861541e-06,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,hitting-probability/cold-all-states,0.0006432080117519945,2.79152300208807e-06,0.0006411037466023117,0.0006510210005217232,0.0006413749943021685,0.0006454999966081232,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,hitting-time/cold-all-states,0.001349958503851667,4.4165062718093395e-06,0.0013455310036079027,0.0013541662628995255,0.001346103977994062,0.0013535000034607947,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,hitting/bounded/at-most/k-10,0.00017735350411385298,1.2700038496404886e-06,0.00017606274923309684,0.0001785002605174668,0.00017641598242335021,0.00017804150411393493,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,hitting/bounded/at-most/k-100,0.001715521008009091,6.7294895416125655e-06,0.0017109272375819273,0.0017277709994232282,0.001712207988020964,0.001724417001241818,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,hitting/bounded/exact/k-10,0.00017541699344292283,8.53513483889401e-07,0.00017471923638368025,0.0001763225081958808,0.00017481199465692044,0.00017620850121602416,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,hitting/bounded/exact/k-100,0.001705374990706332,7.062000804580748e-06,0.0016978230050881393,0.0017110519911511801,0.0017001249943859875,0.001709666510578245,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,hitting/bounded/greater-than/k-10,0.00017739550094120204,1.3954995665699244e-06,0.00017621850565774366,0.00017884324915939942,0.00017670801025815308,0.00017802257571020164,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,hitting/bounded/greater-than/k-100,0.0017078959936043248,3.874985850416124e-06,0.0017050517490133643,0.0017127497485489585,0.0017060420068446547,0.0017100624972954392,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,power/10,0.0011875829950440675,6.854100502096117e-05,0.00112217701098416,0.00128320849762531,0.0011283479045232526,0.001266645995201543,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,power/100,0.0011790625139838085,2.1750020096078515e-05,0.0011616772535489872,0.0012285002449061722,0.0011640625161817297,0.0012013340019620955,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,power/2,0.0010858129971893504,1.9169965526089072e-06,0.0010843127602129243,0.001089114994101692,0.0010844790085684508,0.0010875415027840063,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,return/bounded/k-10,0.00017602099978830665,1.624997821636498e-06,0.00017460374510847032,0.00017854126781458035,0.0001748959912220016,0.0001771039969753474,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,return/bounded/k-100,0.0017135834932560101,1.2416494428180158e-05,0.00170288573281141,0.0017289377501583658,0.0017036664939951152,0.0017225209885509685,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,stationary,0.0011508954921737313,2.3999498807825148e-05,0.0011305312436888926,0.0011907497464562766,0.0011416665074648336,0.0011846286484797019,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,structure/classes-cold,0.00016058300388976932,1.395485014654696e-06,0.00015954176342347637,0.00016319799760822207,0.00015995849389582872,0.00016150000737980008,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,structure/classes-lifecycle,0.00947910400282126,0.00019985450489912182,0.009307594002166297,0.01013599998987047,0.009369292005430907,0.009738833497976884,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,structure/classes-warm/access,2.1650000126101078e-07,9.250506991520717e-10,2.158479270292446e-07,2.1951147573417982e-07,2.1600420150207356e-07,2.1939590078545735e-07,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,structure/classes-warm/consumed,5.65155835065525e-06,5.558755074162043e-08,5.599298949528019e-06,5.7215375498344654e-06,5.610010350937955e-06,5.676737499015872e-06,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,structure/cyclic-classes-cold,0.005291458001011051,0.00020945750293321908,0.005100655762362294,0.006044103989552241,0.0051030625036219135,0.005851729496498592,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,structure/cyclic-classes-warm,7.955539600516204e-06,4.905834939563605e-08,7.910765599808656e-06,8.002497898996808e-06,7.924554200144485e-06,7.992906250001397e-06,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,structure/irreducible-cold,0.00015533299301750958,1.832493580877781e-06,0.00015407323371618986,0.00015852024807827547,0.00015447898476850241,0.00015693699242547154,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,structure/irreducible-warm,2.3746040096739308e-07,6.656300683971488e-09,2.2904692450538275e-07,2.426114500849508e-07,2.309686999069527e-07,2.419521013507619e-07,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,structure/period-cold,0.0030460204870905727,2.9999995604157448e-05,0.003014801739482209,0.0030701245123054832,0.0030279579950729385,0.0030678540060762316,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,structure/period-warm,2.282187997479923e-07,3.957509761676253e-10,2.2795207332819703e-07,2.2868329906486908e-07,2.280562519445084e-07,2.2845210041850805e-07,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,visits/bounded-expectation/k-10,0.00010077100887428969,5.770503776147962e-06,9.559325553709641e-05,0.00011515650840010494,9.643749217502773e-05,0.00010891701094806194,30 +pydtmc,periodic-n0100-s02718,periodic,100,2718,visits/bounded-expectation/k-100,0.00022493749565910548,1.8334831111133099e-06,0.00022356199042405933,0.00022716700186720118,0.00022404149058274925,0.0002264789945911616,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,construction/public-consumed,0.008977875506388955,4.995850031264126e-05,0.008943031483795494,0.00906976024270989,0.008948041999246925,0.009035812501679175,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,evolution/k-10,0.00013727099576499313,1.0629883036017418e-06,0.00013623926497530192,0.00013861500337952748,0.0001365624921163544,0.00013777099957223982,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,evolution/k-100,0.0004400830075610429,2.7710048016160727e-06,0.00043763474241131917,0.00044286451884545386,0.00043827149784192443,0.0004415210132719949,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,evolution/one-step,0.00012168750981800258,1.7603510059416294e-05,0.00010596849460853264,0.0001604587523615919,0.00010712500079534948,0.00015868346999923212,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,finite-time/n-step/k-10,0.00013387500075623393,8.540082490071654e-07,0.00013318700075615197,0.00013545851106755435,0.0001333124964730814,0.0001345000055152923,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,finite-time/n-step/k-100,0.00043241650564596057,2.854008926078677e-06,0.0004309690120862797,0.00043921874748775735,0.0004315624973969534,0.0004380210011731833,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,finite-time/observation/k-10,0.0001711670047370717,1.7041500541381538e-05,0.0001624999931664206,0.00019088550470769405,0.00016406200302299112,0.00018168750102631748,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,finite-time/observation/k-100,0.00043512549018487334,1.6254925867542624e-06,0.0004336042547947727,0.0004370629831100814,0.00043414598621893674,0.0004362089966889471,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,finite-time/step,2.645509084686637e-06,6.250047590583563e-08,2.5830231606960297e-06,2.708737156353891e-06,2.5839981390163302e-06,2.6874913601204753e-06,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,hitting-probability/cold-all-states,0.0006682915118290111,2.6437512133270502e-05,0.0006418229968403466,0.0006933855111128651,0.0006444165046559647,0.0006864159950055182,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,hitting-time/cold-all-states,0.0013494165032170713,4.708505002781749e-06,0.0013447079982142895,0.0013526252441806719,0.001344729505944997,0.0013508129923138767,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,hitting/bounded/at-most/k-10,0.00017754200962372124,1.4795077731832862e-06,0.00017606197798158973,0.0001789894959074445,0.00017627100169193,0.00017829201533459127,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,hitting/bounded/at-most/k-100,0.0018905420001829043,8.395849727094173e-05,0.0017676662464509718,0.00193899949954357,0.0017897915095090866,0.0019278750114608556,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,hitting/bounded/exact/k-10,0.00017543700232636184,8.744827937334776e-07,0.000174832995980978,0.00017670849774731323,0.00017487499280832708,0.00017631197988521308,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,hitting/bounded/exact/k-100,0.0017669585067778826,7.254150114022195e-05,0.0017020837476593442,0.0019778959976974875,0.001707770992652513,0.0019255414954386652,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,hitting/bounded/greater-than/k-10,0.00017995850066654384,2.7295027393847704e-06,0.00017829173884820193,0.00020189525821479037,0.0001785414933692664,0.00019677051750477403,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,hitting/bounded/greater-than/k-100,0.0017303329950664192,2.3791493731550872e-05,0.0017127702521975152,0.001834458002122119,0.0017162290023406968,0.0017905205022543669,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,power/10,0.001117958512622863,3.021006705239415e-06,0.001115124745410867,0.001121468514611479,0.0011159999994561076,0.0011193750251550227,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,power/100,0.0011606875050347298,2.5625049602240324e-06,0.001159448001999408,0.0011648547442746349,0.0011598125129239634,0.0011639159929472953,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,power/2,0.0010863335046451539,2.208500518463552e-06,0.0010846562436199747,0.0010893022481468506,0.0010849585087271407,0.001088229488232173,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,return/bounded/k-10,0.00017591650248505175,9.164941729977727e-07,0.0001748232389218174,0.0001764792323228903,0.00017499999376013875,0.00017635450058151037,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,return/bounded/k-100,0.0017286255024373531,2.37500062212348e-05,0.0017107704989030026,0.0017768442339729518,0.0017125209997175261,0.0017585830064490438,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,stationary,0.0011373749875929207,8.082992280833423e-06,0.0011314789880998433,0.0011540519990376197,0.0011327499960316345,0.0011452494945842773,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,structure/classes-cold,0.00016131300071720034,1.0840012691915035e-06,0.00016021848568925634,0.00016237501404248178,0.00016050049453042448,0.00016204252060560975,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,structure/classes-lifecycle,0.009188333482597955,3.274952177889645e-05,0.009140749738435261,0.00921641648892546,0.009167203284232527,0.009211187512846664,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,structure/classes-warm/access,2.178624999942258e-07,8.437506039627054e-10,2.173479755583685e-07,2.401926765742246e-07,2.1743749966844915e-07,2.2889579995535313e-07,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,structure/classes-warm/consumed,5.6118916982086375e-06,1.5060401347000073e-08,5.591680173529312e-06,5.626573976041982e-06,5.602550000185147e-06,5.625152100401465e-06,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,structure/cyclic-classes-cold,0.0051470419857650995,4.766650090459734e-05,0.005101332993945107,0.00519678124692291,0.005113416496897116,0.005190979485632852,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,structure/cyclic-classes-warm,7.900870848970954e-06,1.5156250447035813e-08,7.894515625957864e-06,7.925816677015974e-06,7.897137498366646e-06,7.920977100729942e-06,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,structure/irreducible-cold,0.0001563125115353614,9.375071385875344e-07,0.00015535450802417472,0.0001570625026943162,0.0001555204944452271,0.0001567914878251031,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,structure/irreducible-warm,2.2562914818990973e-07,3.749984898604428e-10,2.251197256555315e-07,2.258145497762598e-07,2.25266651250422e-07,2.257313011796214e-07,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,structure/period-cold,0.003047979000257328,9.603492799215019e-06,0.003037145761481952,0.0030554272379959,0.003038375507458113,0.003051395498914644,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,structure/period-warm,2.3161249991971997e-07,2.645798667799655e-09,2.2940209964872336e-07,2.4686764954822136e-07,2.3023124958854167e-07,2.387562504736707e-07,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,visits/bounded-expectation/k-10,0.00012039599823765457,1.0375486453995109e-05,0.0001093227620003745,0.00012856248940806836,0.00011397083253541496,0.00012697948841378093,30 +pydtmc,periodic-n0100-s31415,periodic,100,31415,visits/bounded-expectation/k-100,0.0002511039929231629,1.3833006960339844e-05,0.00023736524599371478,0.0002687184969545342,0.00024172897974494845,0.0002581040025688708,30 +pydtmc,periodic-n0250-s01729,periodic,250,1729,construction/public-consumed,0.05401020850695204,0.00010906250099651515,0.05395376024534926,0.05425233350251801,0.05397352101863362,0.054165175155139876,30 +pydtmc,periodic-n0250-s01729,periodic,250,1729,evolution/k-10,0.00033422900014556944,4.375018761493266e-06,0.00033037476532626897,0.0003442812303546816,0.0003316664951853454,0.0003378340043127537,30 +pydtmc,periodic-n0250-s01729,periodic,250,1729,evolution/k-100,0.001245854000444524,3.4580007195472717e-06,0.00124287475773599,0.001253624985110946,0.0012441670114640146,0.0012489585060393438,30 +pydtmc,periodic-n0250-s01729,periodic,250,1729,evolution/one-step,0.0002466869918862358,3.7284917198121548e-06,0.00024343799304915592,0.000251926998316776,0.00024506250338163227,0.0002503602216165745,30 +pydtmc,periodic-n0250-s01729,periodic,250,1729,hitting-probability/cold-all-states,0.007456083490978926,2.3375017917715013e-05,0.0074400940065970644,0.007479625252017286,0.007445604482199997,0.0074766250036191195,30 +pydtmc,periodic-n0250-s01729,periodic,250,1729,hitting-time/cold-all-states,0.015798354492289945,4.7667010221630335e-05,0.015744510747026652,0.01583379123621853,0.01575539549230598,0.015818291998584755,30 +pydtmc,periodic-n0250-s01729,periodic,250,1729,power/10,0.005560416990192607,4.706249455921352e-05,0.005513073250767775,0.005593395741016138,0.005519937491044402,0.005583465269592125,30 +pydtmc,periodic-n0250-s01729,periodic,250,1729,power/100,0.005979415989713743,3.1896503060124815e-05,0.005957218731055036,0.006013010242895689,0.005966066281689564,0.006001749497954734,30 +pydtmc,periodic-n0250-s01729,periodic,250,1729,power/2,0.00518310401821509,8.999530109576881e-06,0.0051743234871537425,0.005192833763430826,0.005175854006665759,0.005189457995584235,30 +pydtmc,periodic-n0250-s01729,periodic,250,1729,stationary,0.007515436998801306,7.76244851294905e-05,0.0074534270024742,0.007670270497328602,0.007467957999324426,0.0075984374998370185,30 +pydtmc,periodic-n0250-s01729,periodic,250,1729,structure/classes-cold,0.0005296455201460049,4.624991561286151e-06,0.0005261772676021792,0.0005360625073080882,0.0005275209987303242,0.000533354002982378,30 +pydtmc,periodic-n0250-s01729,periodic,250,1729,structure/classes-lifecycle,0.05461364600341767,0.00024304151884280145,0.054398676998971496,0.05485963527462445,0.05449333300930448,0.05480689601972699,30 +pydtmc,periodic-n0250-s01729,periodic,250,1729,structure/classes-warm/access,2.1667915134457872e-07,1.0749994544312284e-09,2.1586874936474488e-07,2.1817604938405564e-07,2.161666488973424e-07,2.1769999875687062e-07,30 +pydtmc,periodic-n0250-s01729,periodic,250,1729,structure/classes-warm/consumed,1.3573979200737086e-05,2.7456300449558112e-08,1.3554062524053734e-05,1.3610498898196965e-05,1.3556575000984594e-05,1.3605310399725569e-05,30 +pydtmc,periodic-n0250-s01729,periodic,250,1729,structure/cyclic-classes-cold,0.02524937450652942,0.0001146260037785396,0.025143844264675863,0.0253648962607258,0.02519433302222751,0.02533704199595377,30 +pydtmc,periodic-n0250-s01729,periodic,250,1729,structure/cyclic-classes-warm,1.941514170030132e-05,1.1846044944832078e-07,1.929960310080787e-05,1.9664454175654103e-05,1.9357585015459335e-05,1.9555941650469322e-05,30 +pydtmc,periodic-n0250-s01729,periodic,250,1729,structure/irreducible-cold,0.0005867290019523352,7.156250649131835e-05,0.0005058435053797439,0.0006250204896787181,0.0005140004941495135,0.0006123334896983579,30 +pydtmc,periodic-n0250-s01729,periodic,250,1729,structure/irreducible-warm,2.240395508124493e-07,1.3978511560708225e-09,2.2302187571767717e-07,2.436415998090524e-07,2.2333749802783132e-07,2.3461874952772634e-07,30 +pydtmc,periodic-n0250-s01729,periodic,250,1729,structure/period-cold,0.016267958024400286,0.00014170802023727447,0.016180115002498496,0.016456718512927182,0.016185354499612004,0.01643347949720919,30 +pydtmc,periodic-n0250-s01729,periodic,250,1729,structure/period-warm,2.3207295016618444e-07,8.520015398971895e-10,2.2859477467136458e-07,2.327323003555648e-07,2.3010819673800144e-07,2.326249988982454e-07,30 +pydtmc,periodic-n0250-s02718,periodic,250,2718,construction/public-consumed,0.05388679148745723,0.00012791648623533547,0.05381034424499376,0.0541077187663177,0.05383479199372232,0.05392925001797266,30 +pydtmc,periodic-n0250-s02718,periodic,250,2718,evolution/k-10,0.0003343330026837066,7.478505722247064e-06,0.000329458482156042,0.0003593749934225343,0.0003307710139779374,0.0003468334907665849,30 +pydtmc,periodic-n0250-s02718,periodic,250,2718,evolution/k-100,0.0012444790045265108,6.853995728306472e-06,0.001240082987351343,0.0012578130044857971,0.0012416255049174652,0.0012521665048552677,30 +pydtmc,periodic-n0250-s02718,periodic,250,2718,evolution/one-step,0.00024172950361389667,2.6255002012476325e-06,0.00023860450164647773,0.00024378152011195198,0.0002398540236754343,0.00024337500508408993,30 +pydtmc,periodic-n0250-s02718,periodic,250,2718,hitting-probability/cold-all-states,0.00748622948594857,2.993750968016684e-05,0.007464707989129238,0.007522156513005029,0.007476187514839694,0.007509808170652831,30 +pydtmc,periodic-n0250-s02718,periodic,250,2718,hitting-time/cold-all-states,0.015763041999889538,2.5917019229382277e-05,0.01574443698336836,0.015789843491802458,0.015752583014545962,0.015776957996422425,30 +pydtmc,periodic-n0250-s02718,periodic,250,2718,power/10,0.005530333495698869,3.0999493901617825e-05,0.005503989988937974,0.005562614263908472,0.005506521003553644,0.005552707996685058,30 +pydtmc,periodic-n0250-s02718,periodic,250,2718,power/100,0.005993812490487471,3.827099862974137e-05,0.005957385503279511,0.006032031509676017,0.005965791497146711,0.006015187507728115,30 +pydtmc,periodic-n0250-s02718,periodic,250,2718,power/2,0.0052426460169954225,6.104201020207256e-05,0.005195499754336197,0.005329531253664754,0.005201583000598475,0.005308061998221092,30 +pydtmc,periodic-n0250-s02718,periodic,250,2718,stationary,0.007457457992131822,2.8249487513676286e-05,0.007427645759889856,0.007482155771867838,0.007436916508595459,0.007472687502740882,30 +pydtmc,periodic-n0250-s02718,periodic,250,2718,structure/classes-cold,0.0005253749986877665,6.5624917624518275e-06,0.0005202505199122243,0.0005603227473329753,0.0005223334883339703,0.0005541455029742792,30 +pydtmc,periodic-n0250-s02718,periodic,250,2718,structure/classes-lifecycle,0.05493929100339301,0.0002496665110811591,0.05456703124946216,0.0551384790087468,0.054729356059033306,0.055090312496759,30 +pydtmc,periodic-n0250-s02718,periodic,250,2718,structure/classes-warm/access,2.1666874963557348e-07,6.457994459197044e-10,2.1616875092149712e-07,2.1804482530569656e-07,2.1635829762089998e-07,2.1749165025539698e-07,30 +pydtmc,periodic-n0250-s02718,periodic,250,2718,structure/classes-warm/consumed,1.3546383297943974e-05,2.6352051645517135e-08,1.3536538599873894e-05,1.3617334325681441e-05,1.3541000000259373e-05,1.3583345798542722e-05,30 +pydtmc,periodic-n0250-s02718,periodic,250,2718,structure/cyclic-classes-cold,0.025312375000794418,0.0001287500053877011,0.025183364734402858,0.025437093747314066,0.025201520998962224,0.02541785399080254,30 +pydtmc,periodic-n0250-s02718,periodic,250,2718,structure/cyclic-classes-warm,1.938340830092784e-05,6.098129961173985e-08,1.9324691625661215e-05,1.9444690674572485e-05,1.9336343750183e-05,1.9420187501236793e-05,30 +pydtmc,periodic-n0250-s02718,periodic,250,2718,structure/irreducible-cold,0.0005184370093047619,6.270507583394647e-06,0.0005143957459949888,0.0005482085034600459,0.0005147705087438226,0.0005241660110186785,30 +pydtmc,periodic-n0250-s02718,periodic,250,2718,structure/irreducible-warm,2.2549794957740232e-07,1.729150244500484e-09,2.243750263005495e-07,2.3109892499633133e-07,2.2472499986179175e-07,2.2872085100971162e-07,30 +pydtmc,periodic-n0250-s02718,periodic,250,2718,structure/period-cold,0.016341333495802246,0.0001033750013448298,0.016219083248870447,0.01639515649731038,0.01624987498507835,0.01636935399437789,30 +pydtmc,periodic-n0250-s02718,periodic,250,2718,structure/period-warm,2.3208960046758875e-07,2.7396017685532588e-09,2.2994477621978149e-07,2.498687019397039e-07,2.3076659999787807e-07,2.4178754974855107e-07,30 +pydtmc,periodic-n0250-s31415,periodic,250,31415,construction/public-consumed,0.05427912500454113,0.00020393749582581222,0.05406570775085129,0.05447795824147761,0.05411541601642966,0.054395041515817866,30 +pydtmc,periodic-n0250-s31415,periodic,250,31415,evolution/k-10,0.00036627051304094493,2.7895497623831034e-05,0.00033825001446530223,0.0003842292499030009,0.0003397710097488016,0.0003777352609176887,30 +pydtmc,periodic-n0250-s31415,periodic,250,31415,evolution/k-100,0.0012727705034194514,2.8271504561416805e-05,0.0012531764950836077,0.0013138127542333677,0.0012574584980029613,0.0012999165046494454,30 +pydtmc,periodic-n0250-s31415,periodic,250,31415,evolution/one-step,0.0002658334851730615,2.300000051036477e-05,0.00024498924904037267,0.0003033437460544519,0.0002461870026309043,0.0002859579981304705,30 +pydtmc,periodic-n0250-s31415,periodic,250,31415,hitting-probability/cold-all-states,0.00748727101017721,2.327098627574742e-05,0.007471041491953656,0.007514333745348267,0.007474630363867618,0.007503082990297116,30 +pydtmc,periodic-n0250-s31415,periodic,250,31415,hitting-time/cold-all-states,0.015856395999435335,7.331249071285129e-05,0.015816020269994624,0.016286874750221614,0.015822457993635908,0.01606297898979392,30 +pydtmc,periodic-n0250-s31415,periodic,250,31415,power/10,0.005561687023146078,5.456151848193258e-05,0.005509208756848238,0.005615551752271131,0.0055256875057239085,0.005580249999184161,30 +pydtmc,periodic-n0250-s31415,periodic,250,31415,power/100,0.006572437516297214,0.0002230829995824024,0.006318552259472199,0.006713708491588477,0.006369416500092484,0.00668575000599958,30 +pydtmc,periodic-n0250-s31415,periodic,250,31415,power/2,0.00517954200040549,9.958501323126256e-06,0.005172958510229364,0.0052380312627064995,0.005174103993340395,0.005208145987126045,30 +pydtmc,periodic-n0250-s31415,periodic,250,31415,stationary,0.007449291500961408,1.4229502994567156e-05,0.0074369684953126125,0.007463677247869782,0.007442185428226367,0.007457919108128408,30 +pydtmc,periodic-n0250-s31415,periodic,250,31415,structure/classes-cold,0.0005224374908721074,2.1249870769679546e-06,0.0005206142595852725,0.0005258749952190556,0.0005213955155340955,0.0005239999882178381,30 +pydtmc,periodic-n0250-s31415,periodic,250,31415,structure/classes-lifecycle,0.05449568749463651,0.0001309789950028062,0.054363759998523165,0.054626072487735655,0.054414645506767556,0.05460683349519968,30 +pydtmc,periodic-n0250-s31415,periodic,250,31415,structure/classes-warm/access,2.160749994800426e-07,3.2290117815136473e-10,2.1587187438854016e-07,2.1673745068255814e-07,2.159999989089556e-07,2.1644585067406299e-07,30 +pydtmc,periodic-n0250-s31415,periodic,250,31415,structure/classes-warm/consumed,1.3533227099105716e-05,1.8064600590150937e-08,1.346725932598929e-05,1.3542770824278706e-05,1.3491193750815e-05,1.3540854200255126e-05,30 +pydtmc,periodic-n0250-s31415,periodic,250,31415,structure/cyclic-classes-cold,0.025173541987896897,7.20415118848905e-05,0.02513727049517911,0.025264062758651562,0.025139770514215343,0.02524468749470543,30 +pydtmc,periodic-n0250-s31415,periodic,250,31415,structure/cyclic-classes-warm,1.9312366648227906e-05,1.0735830001067426e-07,1.9226171824266202e-05,1.9493696824793008e-05,1.925472295115469e-05,1.937918749899836e-05,30 +pydtmc,periodic-n0250-s31415,periodic,250,31415,structure/irreducible-cold,0.0005110205092933029,5.853507900610566e-06,0.000506260505062528,0.0005184897454455495,0.0005092710052849725,0.0005155209946678951,30 +pydtmc,periodic-n0250-s31415,periodic,250,31415,structure/irreducible-warm,2.2439994936576113e-07,3.4789845813065844e-10,2.2415420098695905e-07,2.2505832530441696e-07,2.2418540029320865e-07,2.2478750033769756e-07,30 +pydtmc,periodic-n0250-s31415,periodic,250,31415,structure/period-cold,0.016282917000353336,6.87294959789142e-05,0.016221468504227232,0.016357333508494776,0.016231708505074494,0.016313166997861117,30 +pydtmc,periodic-n0250-s31415,periodic,250,31415,structure/period-warm,2.2908954997546972e-07,5.249996320344482e-10,2.285864502482582e-07,2.2961145004956053e-07,2.2877704905113205e-07,2.2952289873501288e-07,30 +pydtmc,periodic-n0500-s01729,periodic,500,1729,construction/public-consumed,0.22144079150166363,0.0015397495008073747,0.21915101024933392,0.22201199975825148,0.2196046659955755,0.2217598545103101,30 +pydtmc,periodic-n0500-s01729,periodic,500,1729,evolution/k-10,0.0010349374933866784,9.450000652577728e-05,0.0009593957511242479,0.001130906748585403,0.0009983335039578378,0.0011043330014217645,30 +pydtmc,periodic-n0500-s01729,periodic,500,1729,evolution/k-100,0.004221354494802654,4.8999994760379195e-05,0.004190104235021863,0.004313437006203458,0.004201146002742462,0.004260521003743634,30 +pydtmc,periodic-n0500-s01729,periodic,500,1729,evolution/one-step,0.0007488745031878352,4.127148713450879e-05,0.0007140105008147657,0.0008099792612483725,0.000729687511920929,0.0007893959991633892,30 +pydtmc,periodic-n0500-s01729,periodic,500,1729,hitting-probability/cold-all-states,0.052252833513193764,0.00036787499266210943,0.05186841675458709,0.05251559348835144,0.051957374991616234,0.052439353996305726,30 +pydtmc,periodic-n0500-s01729,periodic,500,1729,hitting-time/cold-all-states,0.11214297900733072,0.0007924165111035109,0.11139614600688219,0.11304493748320965,0.1116227915044874,0.11277891699864995,30 +pydtmc,periodic-n0500-s01729,periodic,500,1729,power/10,0.02486056300404016,0.00015181249182205647,0.02471997925749747,0.02501724974717945,0.024748875497607514,0.02495741649181582,30 +pydtmc,periodic-n0500-s01729,periodic,500,1729,power/100,0.028189791497425176,0.00043306199950166047,0.02777587499440415,0.02880835401447257,0.02789424949150998,0.028520833497168496,30 +pydtmc,periodic-n0500-s01729,periodic,500,1729,power/2,0.021937854500720277,0.0001321880117757246,0.021799458241730463,0.02203792676300509,0.02185002098849509,0.02201037501799874,30 +pydtmc,periodic-n0500-s01729,periodic,500,1729,stationary,0.04728310448990669,0.00026125001022592187,0.04709535400616005,0.047566645516781136,0.0472227499994915,0.047367499995743856,30 +pydtmc,periodic-n0500-s01729,periodic,500,1729,structure/classes-cold,0.0015987915103323758,2.1063009626232088e-05,0.0015814474900253117,0.0016327917546732351,0.0015872084914008155,0.0016226660081883892,30 +pydtmc,periodic-n0500-s01729,periodic,500,1729,structure/classes-lifecycle,0.2251769165013684,0.002004208494327031,0.2227670729989768,0.22671690576680703,0.22334914599196054,0.22658449951268267,30 +pydtmc,periodic-n0500-s01729,periodic,500,1729,structure/classes-warm/access,2.1710830042138697e-07,8.499991963617527e-10,2.159770745493006e-07,2.1790937535115517e-07,2.1634374861605467e-07,2.1774995111627505e-07,30 +pydtmc,periodic-n0500-s01729,periodic,500,1729,structure/classes-warm/consumed,2.8811906250484753e-05,4.600210086209622e-08,2.8772472925629696e-05,2.8870011473918566e-05,2.877794375090161e-05,2.8856143751181663e-05,30 +pydtmc,periodic-n0500-s01729,periodic,500,1729,structure/cyclic-classes-cold,0.0969378544978099,0.0004231664934195578,0.09660205223917728,0.09881159401265904,0.09670158299559262,0.09775358349725138,30 +pydtmc,periodic-n0500-s01729,periodic,500,1729,structure/cyclic-classes-warm,4.0532864601118494e-05,4.206879966659713e-08,4.046845830016537e-05,4.0553438549250133e-05,4.048906660173088e-05,4.054655209911289e-05,30 +pydtmc,periodic-n0500-s01729,periodic,500,1729,structure/irreducible-cold,0.001586229496751912,2.897948434110731e-05,0.0015626147360308096,0.0016503639999427833,0.0015642710059182718,0.0016311460203723982,30 +pydtmc,periodic-n0500-s01729,periodic,500,1729,structure/irreducible-warm,2.249187498819083e-07,6.749978638254153e-10,2.2452082339441403e-07,2.2587917555938475e-07,2.246416494017467e-07,2.2569374996237456e-07,30 +pydtmc,periodic-n0500-s01729,periodic,500,1729,structure/period-cold,0.06463339550828096,0.0002642914914758876,0.06445079150580568,0.06497591625520727,0.06452018352829328,0.06482435400539543,30 +pydtmc,periodic-n0500-s01729,periodic,500,1729,structure/period-warm,2.2904375073267147e-07,1.381250331178313e-09,2.2793440075474792e-07,2.3102192571968772e-07,2.281041000969708e-07,2.3082500119926408e-07,30 +pydtmc,periodic-n0500-s02718,periodic,500,2718,construction/public-consumed,0.22254847901058383,0.0016794999974081293,0.22026364575867774,0.22376648924546316,0.2209693545009941,0.22352520799904596,30 +pydtmc,periodic-n0500-s02718,periodic,500,2718,evolution/k-10,0.0009658540075179189,6.102101178839803e-05,0.0008975520104286261,0.0009949894883902743,0.0009265414992114529,0.000990478991298005,30 +pydtmc,periodic-n0500-s02718,periodic,500,2718,evolution/k-100,0.004043458015075885,1.7916507204063237e-05,0.004025750000437256,0.0040603747620480135,0.004030917014461011,0.004056353500345722,30 +pydtmc,periodic-n0500-s02718,periodic,500,2718,evolution/one-step,0.0006969165115151554,2.9791524866595864e-05,0.0006669999856967479,0.0007223755092127249,0.0006699789955746382,0.0007127919961931184,30 +pydtmc,periodic-n0500-s02718,periodic,500,2718,hitting-probability/cold-all-states,0.052943958013202064,0.0006137705204309896,0.052326489734696224,0.05350301050202688,0.05238627099606674,0.053441479001776315,30 +pydtmc,periodic-n0500-s02718,periodic,500,2718,hitting-time/cold-all-states,0.11274554149713367,0.0006719164812238887,0.11215115652157692,0.1134449167366256,0.11223195849743206,0.11327764599991497,30 +pydtmc,periodic-n0500-s02718,periodic,500,2718,power/10,0.024690437494427897,0.00012002050061710179,0.024613687761302572,0.024818021011014935,0.024631541993585415,0.024792875003186055,30 +pydtmc,periodic-n0500-s02718,periodic,500,2718,power/100,0.027705979518941604,0.000160541501827538,0.027581177004321944,0.02795430174592184,0.027619041487923823,0.027870020508999005,30 +pydtmc,periodic-n0500-s02718,periodic,500,2718,power/2,0.02198558350210078,0.00012470799265429378,0.021845916991878767,0.022064291486458387,0.02189416650799103,0.022045396006433293,30 +pydtmc,periodic-n0500-s02718,periodic,500,2718,stationary,0.04930308350594714,0.002021020496613346,0.047263552514777984,0.05112148926855298,0.04743962500651833,0.050861082985647954,30 +pydtmc,periodic-n0500-s02718,periodic,500,2718,structure/classes-cold,0.0015943955077091232,1.1687006917782128e-05,0.001589572500961367,0.0016169272348633967,0.0015901665028650314,0.0016028120007831603,30 +pydtmc,periodic-n0500-s02718,periodic,500,2718,structure/classes-lifecycle,0.22247608299949206,0.0013938954944023862,0.22112352099793497,0.22403544776170747,0.2213414375000866,0.223591354500968,30 +pydtmc,periodic-n0500-s02718,periodic,500,2718,structure/classes-warm/access,2.182041498599574e-07,1.9729006453417186e-09,2.164041252399329e-07,2.2031454936950468e-07,2.1652704734151485e-07,2.1973960101604462e-07,30 +pydtmc,periodic-n0500-s02718,periodic,500,2718,structure/classes-warm/consumed,2.878216249955585e-05,1.4870851009619637e-08,2.8446246875682845e-05,2.8792868775053645e-05,2.8621812499477528e-05,2.8788729099323975e-05,30 +pydtmc,periodic-n0500-s02718,periodic,500,2718,structure/cyclic-classes-cold,0.09656704199733213,0.00038314600533340126,0.09620251100568566,0.09698762524931226,0.09636085398960859,0.09681024999008514,30 +pydtmc,periodic-n0500-s02718,periodic,500,2718,structure/cyclic-classes-warm,4.043975624954328e-05,1.7490415048086974e-07,4.02272739505861e-05,4.057258017492131e-05,4.033578539965674e-05,4.049212704994716e-05,30 +pydtmc,periodic-n0500-s02718,periodic,500,2718,structure/irreducible-cold,0.0015543540066573769,5.750000127591193e-06,0.0015490102596231736,0.001560947741381824,0.001550292014144361,0.0015570581574138485,30 +pydtmc,periodic-n0500-s02718,periodic,500,2718,structure/irreducible-warm,2.277291496284306e-07,3.518750600051136e-09,2.2463222485384904e-07,2.4610727559775114e-07,2.2560420038644226e-07,2.424541497020982e-07,30 +pydtmc,periodic-n0500-s02718,periodic,500,2718,structure/period-cold,0.06507085400517099,0.00033925000752788037,0.06488215600256808,0.06621558347978862,0.0649905625032261,0.0656183335086098,30 +pydtmc,periodic-n0500-s02718,periodic,500,2718,structure/period-warm,2.3420204961439594e-07,5.3499490604735916e-09,2.3017817657091655e-07,2.483062504325062e-07,2.3262915055966005e-07,2.4101040180539713e-07,30 +pydtmc,periodic-n0500-s31415,periodic,500,31415,construction/public-consumed,0.22273425001185387,0.0020082914852537215,0.22081708374025766,0.22440310399542795,0.22155164601281285,0.22346006249426864,30 +pydtmc,periodic-n0500-s31415,periodic,500,31415,evolution/k-10,0.00102385449281428,4.522899689618498e-05,0.0009952497566700913,0.0011039577366318554,0.001001833486952819,0.001061934019890031,30 +pydtmc,periodic-n0500-s31415,periodic,500,31415,evolution/k-100,0.004124187500565313,5.187450733501464e-05,0.004074072996445466,0.004170707754383329,0.00407841699779965,0.004145437502302229,30 +pydtmc,periodic-n0500-s31415,periodic,500,31415,evolution/one-step,0.0006886874907650054,2.3062486434355378e-05,0.0006653545133303851,0.0007077294867485762,0.0006676880002487451,0.0007000415062066168,30 +pydtmc,periodic-n0500-s31415,periodic,500,31415,hitting-probability/cold-all-states,0.05213616701075807,0.0004746460181195289,0.051883625004848,0.05337003099702997,0.05191385350190103,0.052996749989688396,30 +pydtmc,periodic-n0500-s31415,periodic,500,31415,hitting-time/cold-all-states,0.11204574999283068,0.0005872295005246997,0.11151107323530596,0.11263594824413303,0.11180966701067518,0.1123619999998482,30 +pydtmc,periodic-n0500-s31415,periodic,500,31415,power/10,0.024661729010404088,8.668699592817575e-05,0.024598146505013574,0.024838801997248083,0.024610416498035192,0.024749493230046937,30 +pydtmc,periodic-n0500-s31415,periodic,500,31415,power/100,0.02774339598545339,0.00015002049622125924,0.02758010425895918,0.027879030763870105,0.02764183349790983,0.02783522949903272,30 +pydtmc,periodic-n0500-s31415,periodic,500,31415,power/2,0.021861270986846648,0.00010920851491391659,0.0217673227598425,0.02202523951564217,0.02180423697900551,0.021970955560027504,30 +pydtmc,periodic-n0500-s31415,periodic,500,31415,stationary,0.04727683351666201,0.0001866870152298361,0.04709896826534532,0.050871448271209374,0.04713402793022396,0.047384124976815656,30 +pydtmc,periodic-n0500-s31415,periodic,500,31415,structure/classes-cold,0.0015818334941286594,4.832996637560427e-06,0.0015790004981681705,0.0015890837676124647,0.00158031249884516,0.0015871250070631504,30 +pydtmc,periodic-n0500-s31415,periodic,500,31415,structure/classes-lifecycle,0.22362927050562575,0.0024969379883259535,0.2227960520031047,0.22650323998823296,0.22309060400584713,0.2256952080060728,30 +pydtmc,periodic-n0500-s31415,periodic,500,31415,structure/classes-warm/access,2.174624998588115e-07,3.6459969123824825e-10,2.1666667598765344e-07,2.1767809885204768e-07,2.1700210054405034e-07,2.176541485823691e-07,30 +pydtmc,periodic-n0500-s31415,periodic,500,31415,structure/classes-warm/consumed,2.8811037498235236e-05,5.24624992976884e-08,2.8768523999315218e-05,2.8881405224819903e-05,2.878413124999497e-05,2.8865672899701165e-05,30 +pydtmc,periodic-n0500-s31415,periodic,500,31415,structure/cyclic-classes-cold,0.09618733350362163,0.00026418748893775046,0.09593474000575952,0.09651922925695544,0.09597895800834522,0.0963006245001452,30 +pydtmc,periodic-n0500-s31415,periodic,500,31415,structure/cyclic-classes-warm,4.0502281299268356e-05,1.0833950072993066e-07,4.0121340676705587e-05,4.059405000007245e-05,4.032417915004772e-05,4.056851665081922e-05,30 +pydtmc,periodic-n0500-s31415,periodic,500,31415,structure/irreducible-cold,0.0015575215074932203,6.937989383004606e-06,0.0015505212650168687,0.0015631042479071766,0.0015519759050221184,0.0015605624939780682,30 +pydtmc,periodic-n0500-s31415,periodic,500,31415,structure/irreducible-warm,2.2323960001813247e-07,2.916494850069206e-10,2.2303857549559327e-07,2.2392087485059165e-07,2.2309795167529954e-07,2.234895509900525e-07,30 +pydtmc,periodic-n0500-s31415,periodic,500,31415,structure/period-cold,0.064524312998401,0.00039737501356285065,0.06428023925400339,0.0655122702519293,0.06430670802365057,0.06490675001987256,30 +pydtmc,periodic-n0500-s31415,periodic,500,31415,structure/period-warm,2.3097914818208665e-07,3.562498022802096e-10,2.3057605067151598e-07,2.312739750777837e-07,2.3069995077094064e-07,2.311791991814971e-07,30 +pydtmc,periodic-n1000-s01729,periodic,1000,1729,construction/public-consumed,0.875781916489359,0.0019875419820891693,0.8745782812620746,0.8914264377599466,0.8747835005051456,0.8910100984354358,30 +pydtmc,periodic-n1000-s01729,periodic,1000,1729,evolution/k-10,0.004162833996815607,0.00041702149610500783,0.0035335524880792946,0.004399708006531,0.003691895486554131,0.004373729505459778,30 +pydtmc,periodic-n1000-s01729,periodic,1000,1729,evolution/k-100,0.021782604002510197,0.00038008298724889755,0.02124593750340864,0.022075156011851504,0.021451543913644854,0.021991916990373284,30 +pydtmc,periodic-n1000-s01729,periodic,1000,1729,evolution/one-step,0.0023393125156871974,7.933298184070736e-05,0.002296603997820057,0.0024222182473749854,0.0023035210178932175,0.002395833987975493,30 +pydtmc,periodic-n1000-s01729,periodic,1000,1729,structure/classes-cold,0.005303958503645845,1.3479002518579364e-05,0.005290052249620203,0.005316426504577976,0.005296646006172523,0.0053130415035411716,30 +pydtmc,periodic-n1000-s01729,periodic,1000,1729,structure/classes-lifecycle,0.8914811669965275,0.008924166497308761,0.8867391562453122,0.9072409067448461,0.8892764375050319,0.9033352294936776,30 +pydtmc,periodic-n1000-s01729,periodic,1000,1729,structure/classes-warm/access,2.1761454991064966e-07,5.750000127591122e-10,2.164885496313218e-07,2.1812082486576402e-07,2.1730205044150353e-07,2.179708011681214e-07,30 +pydtmc,periodic-n1000-s01729,periodic,1000,1729,structure/classes-warm/consumed,5.934076459961943e-05,2.4104148906189433e-08,5.932287815157907e-05,5.937885727616959e-05,5.9328170849767044e-05,5.936682920146268e-05,30 +pydtmc,periodic-n1000-s01729,periodic,1000,1729,structure/cyclic-classes-cold,0.37231718748807907,0.0010097494814544916,0.3714927500113845,0.3739784272329416,0.3716155004949542,0.3732899790047668,30 +pydtmc,periodic-n1000-s01729,periodic,1000,1729,structure/cyclic-classes-warm,8.320082085119793e-05,1.963437491212997e-07,8.296889584962627e-05,8.337291562420432e-05,8.30111791510717e-05,8.333235414902446e-05,30 +pydtmc,periodic-n1000-s01729,periodic,1000,1729,structure/irreducible-cold,0.005265583502477966,1.3270997442305088e-05,0.005253083247225732,0.0052818955009570345,0.005258749995846301,0.005277062504319474,30 +pydtmc,periodic-n1000-s01729,periodic,1000,1729,structure/irreducible-warm,2.2390834928955884e-07,1.0062009096145605e-09,2.2338855123962276e-07,2.2497917452710682e-07,2.2364159813150764e-07,2.2452089906437321e-07,30 +pydtmc,periodic-n1000-s01729,periodic,1000,1729,structure/period-cold,0.2526767914969241,0.0007929999846965075,0.2518852497669286,0.2533311352453893,0.25198162550805137,0.25286724999023136,30 +pydtmc,periodic-n1000-s01729,periodic,1000,1729,structure/period-warm,2.3032080207485708e-07,4.853995051234912e-10,2.2961877475609069e-07,2.3070409952197224e-07,2.298350886121625e-07,2.3063755070324986e-07,30 +pydtmc,periodic-n1000-s02718,periodic,1000,2718,construction/public-consumed,0.8894914789852919,0.014042896029422991,0.8796890419835108,0.9048689482660848,0.883153813003446,0.8980406869959552,30 +pydtmc,periodic-n1000-s02718,periodic,1000,2718,evolution/k-10,0.004335375502705574,0.0004284994938643649,0.0036813644983340055,0.004547698008536827,0.00391150001087226,0.004518104004091583,30 +pydtmc,periodic-n1000-s02718,periodic,1000,2718,evolution/k-100,0.021969354507746175,0.0004698749980889261,0.020987968491681386,0.022193989745574072,0.021319937499356456,0.02217335399473086,30 +pydtmc,periodic-n1000-s02718,periodic,1000,2718,evolution/one-step,0.0022738125117029995,0.00021095802367199212,0.0018417602550471202,0.0023569167460664175,0.0018571459950180724,0.0023492915061069652,30 +pydtmc,periodic-n1000-s02718,periodic,1000,2718,structure/classes-cold,0.0053065415122546256,1.9041006453335285e-05,0.005291646004479844,0.005334239744115621,0.005298791991663165,0.00532460455870023,30 +pydtmc,periodic-n1000-s02718,periodic,1000,2718,structure/classes-lifecycle,0.8915369585010922,0.008782854507444426,0.8824837809879682,0.8978007192636142,0.8839249375014333,0.8966607295005815,30 +pydtmc,periodic-n1000-s02718,periodic,1000,2718,structure/classes-warm/access,2.170875493902713e-07,1.258349220734092e-09,2.158624993171543e-07,2.1834474900970234e-07,2.1617919992422685e-07,2.1800834947498516e-07,30 +pydtmc,periodic-n1000-s02718,periodic,1000,2718,structure/classes-warm/consumed,5.9444235400587785e-05,6.539370078826226e-08,5.939774792495882e-05,6.112529372549034e-05,5.9418579148768906e-05,6.0002820850058924e-05,30 +pydtmc,periodic-n1000-s02718,periodic,1000,2718,structure/cyclic-classes-cold,0.3712888754962478,0.000717040995368734,0.3705035312450491,0.37194401024316903,0.37092712499725167,0.3717045797209721,30 +pydtmc,periodic-n1000-s02718,periodic,1000,2718,structure/cyclic-classes-warm,8.306182909873313e-05,2.140770986443379e-07,8.286094687646255e-05,8.325662709976314e-05,8.292814585001906e-05,8.312214170146036e-05,30 +pydtmc,periodic-n1000-s02718,periodic,1000,2718,structure/irreducible-cold,0.0052617915062000975,2.175050030928105e-05,0.005239853504463099,0.005277229269267991,0.005244229003437795,0.0052728330047102645,30 +pydtmc,periodic-n1000-s02718,periodic,1000,2718,structure/irreducible-warm,2.2542085062013937e-07,5.89601404499263e-10,2.251781501399819e-07,2.404562990705017e-07,2.253333484986797e-07,2.331333002075553e-07,30 +pydtmc,periodic-n1000-s02718,periodic,1000,2718,structure/period-cold,0.25274347949016374,0.0007467710092896596,0.2518127812509192,0.2533530625150888,0.252062957995804,0.25323520800156984,30 +pydtmc,periodic-n1000-s02718,periodic,1000,2718,structure/period-warm,2.3012080055195837e-07,3.812499926425549e-10,2.298124752996955e-07,2.305114503542427e-07,2.2994999890215696e-07,2.3042920220177621e-07,30 +pydtmc,periodic-n1000-s31415,periodic,1000,31415,construction/public-consumed,0.8893692499841563,0.012683791486779228,0.8770054274864378,0.904864687276131,0.8789882085111458,0.8961328125005821,30 +pydtmc,periodic-n1000-s31415,periodic,1000,31415,evolution/k-10,0.004102625011000782,0.0005315625021466985,0.0034298855025554076,0.004462937999051064,0.003510667011141777,0.004414499504491687,30 +pydtmc,periodic-n1000-s31415,periodic,1000,31415,evolution/k-100,0.02135922948946245,0.0005074370128568262,0.020830499997828156,0.02184273925377056,0.021048228998552077,0.02166339549876284,30 +pydtmc,periodic-n1000-s31415,periodic,1000,31415,evolution/one-step,0.002237604508991353,0.00010174998897127807,0.0018203337385784835,0.002310833500814624,0.0021021044958615676,0.002292701718761236,30 +pydtmc,periodic-n1000-s31415,periodic,1000,31415,structure/classes-cold,0.005299645505147055,2.1958505385555327e-05,0.0052763440035050735,0.005318864248692989,0.005285604507662356,0.005315020986017771,30 +pydtmc,periodic-n1000-s31415,periodic,1000,31415,structure/classes-lifecycle,0.8829933960078051,0.0029051875026198104,0.8807009684896911,0.8989613644953351,0.8822563330031699,0.8870120620122179,30 +pydtmc,periodic-n1000-s31415,periodic,1000,31415,structure/classes-warm/access,2.1619165199808776e-07,7.812501280568555e-10,2.158333249099087e-07,2.1835002553416418e-07,2.1590835094684734e-07,2.1774164924863725e-07,30 +pydtmc,periodic-n1000-s31415,periodic,1000,31415,structure/classes-warm/consumed,5.925139999890235e-05,1.338812493486275e-07,5.888359582459088e-05,5.9311668750888205e-05,5.905734585103346e-05,5.929801040038001e-05,30 +pydtmc,periodic-n1000-s31415,periodic,1000,31415,structure/cyclic-classes-cold,0.3729636255011428,0.0006686879933113232,0.37236828124150634,0.37423969775409205,0.3724238124996191,0.37370933349302504,30 +pydtmc,periodic-n1000-s31415,periodic,1000,31415,structure/cyclic-classes-warm,8.282759994908702e-05,4.4237080001040003e-07,8.238350622341386e-05,8.325832392583835e-05,8.256640205072473e-05,8.319510839937721e-05,30 +pydtmc,periodic-n1000-s31415,periodic,1000,31415,structure/irreducible-cold,0.005237457997282036,1.2520496966317296e-05,0.005227750516496599,0.005253343246295117,0.0052325005090096965,0.005249395500868559,30 +pydtmc,periodic-n1000-s31415,periodic,1000,31415,structure/irreducible-warm,2.25695849803742e-07,6.750007742084668e-10,2.2497922327602282e-07,2.262427493405994e-07,2.251312995213084e-07,2.260166496853344e-07,30 +pydtmc,periodic-n1000-s31415,periodic,1000,31415,structure/period-cold,0.2531764165032655,0.0011868334986502305,0.2513929794949945,0.25381947900314117,0.25229854151257314,0.2535316660068929,30 +pydtmc,periodic-n1000-s31415,periodic,1000,31415,structure/period-warm,2.3172295041149482e-07,4.600000102072951e-09,2.3064587512635626e-07,2.3796149907866494e-07,2.3085840075509624e-07,2.3525414871983232e-07,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,construction/public-consumed,0.0003640214854385704,2.2494932636618614e-06,0.00036236450250726193,0.0003669897487270646,0.00036289550189394504,0.00036624999484047294,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,evolution/k-10,5.256249278318137e-05,1.2294913176447153e-06,5.148949276190251e-05,5.4396004998125136e-05,5.175001570023596e-05,5.3479496273212135e-05,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,evolution/k-100,0.0002598124847281724,9.994982974603772e-07,0.0002584589892649092,0.0002603227549116127,0.0002585840120445937,0.00026022900419775397,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,evolution/one-step,2.9666000045835972e-05,4.990142770111561e-07,2.9353992431424558e-05,3.0989751394372433e-05,2.9479502700269222e-05,3.04790009977296e-05,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,finite-time/n-step/k-10,5.01670001540333e-05,6.664922693744302e-07,4.959350189892575e-05,5.110399069963023e-05,4.9770998884923756e-05,5.0583999836817384e-05,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,finite-time/n-step/k-100,0.0002611874951981008,2.625005436129868e-06,0.00025603124959161505,0.0002632390023791231,0.0002575415128376335,0.0002622515963594196,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,finite-time/observation/k-10,4.964550316799432e-05,4.794856067746878e-07,4.942724626744166e-05,5.085425800643861e-05,4.947949491906911e-05,5.037500523030758e-05,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,finite-time/observation/k-100,0.0002566875045886263,1.8749997252598405e-06,0.0002544997405493632,0.0002572814846644178,0.00025485399237368256,0.0002572499943198636,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,finite-time/step,8.750066626816988e-07,4.1996827349066734e-08,8.330098353326321e-07,9.579816833138466e-07,8.33999365568161e-07,9.170034900307655e-07,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,hitting-probability/cold-all-states,4.289600474294275e-05,6.875052349641919e-07,4.230175545671955e-05,4.492701555136591e-05,4.241600981913507e-05,4.354199336376041e-05,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,hitting-time/cold-all-states,0.00011506301234476268,1.480017090216279e-06,0.00011367649858584628,0.00011871848255395889,0.00011379201896488667,0.00011683398042805493,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,hitting/bounded/at-most/k-10,4.400000034365803e-05,3.335007932037115e-07,4.372950206743553e-05,4.48434948339127e-05,4.381249891594052e-05,4.4416519813239574e-05,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,hitting/bounded/at-most/k-100,0.0003415215032873675,4.3130130507051945e-06,0.00033755148615455255,0.00034561476059025154,0.0003395829990040511,0.0003445415059104562,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,hitting/bounded/exact/k-10,4.300000728107989e-05,7.080088835209608e-07,4.230225022183731e-05,4.3781736167147756e-05,4.2416504584252834e-05,4.345850902609527e-05,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,hitting/bounded/exact/k-100,0.00034291649353690445,3.6455021472647786e-06,0.0003399792476557195,0.00034884373599197716,0.0003412080113776028,0.00034610400325618684,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,hitting/bounded/greater-than/k-10,4.3833497329615057e-05,4.994944902136922e-07,4.342725151218474e-05,4.448976687854156e-05,4.352100950200111e-05,4.4312517275102437e-05,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,hitting/bounded/greater-than/k-100,0.0003406250034458935,2.4165055947378278e-06,0.0003390419951756485,0.00034473975392756984,0.00033952049852814525,0.00034237498766742647,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,occupation-matrix,0.0008766039973124862,5.374997272156179e-06,0.0008715729927644134,0.000881906489667017,0.0008728540124138817,0.0008806045079836622,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,power/10,0.0003052294923691079,1.4795077731832862e-06,0.00030393775523407385,0.00030782350950175896,0.00030441602575592697,0.0003066045028390363,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,power/100,0.00031081300403457135,2.06149707082659e-06,0.00030839574174024165,0.0003126559968222864,0.0003092290135100484,0.0003115625149803236,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,power/2,0.0003028330102097243,2.1454907255247235e-06,0.000300885243632365,0.0003051664971280843,0.0003016459959326312,0.0003044165059691295,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,return/bounded/k-10,4.39790019299835e-05,6.664922693744302e-07,4.346925561549142e-05,4.4770247768610716e-05,4.358350997790694e-05,4.4520493247546256e-05,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,return/bounded/k-100,0.0003367710014572367,2.2500171326100826e-06,0.00033368750155204907,0.00033848974271677434,0.00033549999352544546,0.00033785399864427745,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,stationary,0.00010220801050309092,1.7700076568871737e-06,0.00010042750363936648,0.000103780985227786,0.00010124998516403139,0.00010341698362026364,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,structure/classes-cold,2.6124485884793103e-05,6.255140760913491e-07,2.5614514015614986e-05,2.6770998374558985e-05,2.5833986001089215e-05,2.654151467140764e-05,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,structure/classes-lifecycle,0.0004219170077703893,2.186992787756026e-06,0.00041971926111727953,0.000424020501668565,0.00042072951328009367,0.0004233540239511058,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,structure/classes-warm/access,2.1994999842718243e-07,7.937502232380281e-10,2.1615937366732395e-07,2.2056149973650462e-07,2.1829165052622555e-07,2.2037500166334212e-07,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,structure/classes-warm/consumed,9.972937506972813e-07,1.2771008186974031e-09,9.962854011973832e-07,9.98665600491222e-07,9.96574950113427e-07,9.981562499888242e-07,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,structure/irreducible-cold,2.485451113898307e-05,1.3954995665699244e-06,2.4166482035070658e-05,2.683349885046482e-05,2.4354492779821157e-05,2.641651371959597e-05,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,structure/irreducible-warm,2.3558119864901528e-07,9.9895492894575e-09,2.2498647449538113e-07,2.3917702565086076e-07,2.2559164935955778e-07,2.380333506152965e-07,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,visits/bounded-expectation/k-10,1.9750004867091775e-05,2.0800507627427578e-07,1.958325447048992e-05,2.003076224355027e-05,1.9625003915280104e-05,1.9958504708483815e-05,30 +pydtmc,reducible-n0010-s01729,reducible,10,1729,visits/bounded-expectation/k-100,7.791649841237813e-05,4.1649036575108767e-07,7.764600741211325e-05,7.845851359888911e-05,7.775050471536815e-05,7.822900079190731e-05,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,construction/public-consumed,0.0003646870027296245,3.728506271727383e-06,0.0003610835046856664,0.000369219014828559,0.0003616459871409461,0.00036743700911756605,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,evolution/k-10,5.14579878654331e-05,7.715279934927821e-07,5.0791735702659935e-05,5.2239767683204263e-05,5.102099385112524e-05,5.175001570023596e-05,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,evolution/k-100,0.00025874999118968844,2.8959912015125155e-06,0.0002565832473919727,0.0002632922478369437,0.00025691650807857513,0.00026174950471613556,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,evolution/one-step,2.9958493541926146e-05,8.124916348606348e-07,2.928126195911318e-05,3.081250179093331e-05,2.9416987672448158e-05,3.0499999411404133e-05,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,finite-time/n-step/k-10,5.1416485803201795e-05,1.7079873941838741e-06,4.9968504754360765e-05,5.412500468082726e-05,5.018750380259007e-05,5.316699389368296e-05,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,finite-time/n-step/k-100,0.0002614580007502809,2.103508450090885e-06,0.00025908349198289216,0.00026322900521336123,0.00025977099721785635,0.00026229198556393385,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,finite-time/observation/k-10,5.104148294776678e-05,9.579671313986182e-07,5.0094269681721926e-05,5.202049942454323e-05,5.045798025093973e-05,5.1687005907297134e-05,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,finite-time/observation/k-100,0.0002565000031609088,1.0005023796111345e-06,0.0002558020205469802,0.00025803074095165357,0.00025606249982956797,0.00025693749194033444,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,finite-time/step,8.750066626816988e-07,4.1996827349066734e-08,8.749775588512421e-07,9.5875293482095e-07,8.750066626816988e-07,9.57996235229075e-07,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,hitting-probability/cold-all-states,4.337448626756668e-05,1.2489908840507269e-06,4.225999873597175e-05,4.5405729906633496e-05,4.243799776304513e-05,4.452100256457925e-05,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,hitting-time/cold-all-states,0.00011835449549835175,1.791995600797236e-06,0.00011663499026326463,0.00012015648826491088,0.00011695799184963107,0.00011989551421720535,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,hitting/bounded/at-most/k-10,4.458299372345209e-05,8.955103112384677e-07,4.391599941300228e-05,4.582250403473154e-05,4.3999505578540266e-05,4.531249578576535e-05,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,hitting/bounded/at-most/k-100,0.0003439169959165156,5.374517058953643e-06,0.00033727098343661055,0.00034882300678873435,0.00034137500915676355,0.0003481039893813431,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,hitting/bounded/exact/k-10,4.247900506015867e-05,5.83502696827054e-07,4.2031249904539436e-05,4.341649037087336e-05,4.212500061839819e-05,4.302100569475442e-05,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,hitting/bounded/exact/k-100,0.0003403334994800389,2.7500063879415393e-06,0.0003371560087543912,0.00034228074218844995,0.00033864549186546355,0.0003419795117224567,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,hitting/bounded/greater-than/k-10,4.439600161276758e-05,6.459886208176613e-07,4.377101140562445e-05,4.513549356488511e-05,4.395801806822419e-05,4.493699816521257e-05,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,hitting/bounded/greater-than/k-100,0.00035199949343223125,7.707494660280645e-06,0.000347375484125223,0.00036865624133497477,0.00034870850504375994,0.00036064651794731617,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,occupation-matrix,0.0008757085015531629,2.4585024220868945e-06,0.0008744687656871974,0.0008786872494965792,0.0008749169937800616,0.0008777085022302344,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,power/10,0.00030620850156992674,1.6039994079619646e-06,0.0003049162551178597,0.00030839598912280053,0.00030499999411404133,0.0003073124826187268,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,power/100,0.0003211040166206658,1.3729018974117935e-05,0.0003089059973717667,0.0003646249897428788,0.00031625050178263336,0.0003393749939277768,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,power/2,0.0003013545065186918,1.334003172814846e-06,0.00030043773585930467,0.0003047084901481867,0.0003006874903803691,0.0003034590044990182,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,return/bounded/k-10,4.358298610895872e-05,6.664922693744302e-07,4.297900159144774e-05,4.454201553016901e-05,4.308350617066026e-05,4.3938534145127047e-05,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,return/bounded/k-100,0.00034812498779501766,6.666508852504194e-06,0.00033986425114562735,0.00035194850352127105,0.00034104150836355984,0.0003514789859764278,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,stationary,0.00010058350744657218,1.813023118302226e-06,9.88547399174422e-05,0.00010280225251335651,9.899999713525176e-05,0.00010222899436485022,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,structure/classes-cold,2.597899583633989e-05,4.789908416569233e-07,2.563549787737429e-05,2.702048368519172e-05,2.5707995519042015e-05,2.662499900907278e-05,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,structure/classes-lifecycle,0.0004242705035721883,2.4165055947378278e-06,0.00042217649752274156,0.0004267702461220324,0.000422583005274646,0.00042629201197996736,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,structure/classes-warm/access,2.1691040019504725e-07,5.999492714181478e-10,2.1641357452608643e-07,2.1796250148327088e-07,2.1662294893758372e-07,2.1725630067521708e-07,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,structure/classes-warm/consumed,1.006072899326682e-06,8.26460018288342e-09,9.979489739635028e-07,1.1063499754527584e-06,9.99874999979511e-07,1.0086103997309692e-06,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,structure/irreducible-cold,2.433298504911363e-05,6.249756552278996e-07,2.36870109802112e-05,2.479200338711962e-05,2.3917004000395536e-05,2.4542008759453893e-05,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,structure/irreducible-warm,2.245354495244101e-07,4.687506589107236e-10,2.240562498627696e-07,2.2495312587125226e-07,2.2417709988076238e-07,2.2482500062324108e-07,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,visits/bounded-expectation/k-10,1.9937506294809282e-05,1.6650301404297352e-07,1.9802253518719226e-05,2.0708233932964504e-05,1.9853992853313684e-05,2.0082981791347265e-05,30 +pydtmc,reducible-n0010-s02718,reducible,10,2718,visits/bounded-expectation/k-100,7.847951201256365e-05,4.790053935721517e-07,7.81765193096362e-05,7.929174898890778e-05,7.822949555702507e-05,7.902098877821118e-05,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,construction/public-consumed,0.0003641874936874956,4.041503416374326e-06,0.0003601249845814891,0.0003679272558656521,0.00036068749614059925,0.0003669580037239939,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,evolution/k-10,5.191648961044848e-05,6.67001586407423e-07,5.149999196873978e-05,5.30417455593124e-05,5.1645489293150604e-05,5.260399484541267e-05,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,evolution/k-100,0.0002593335084384307,1.979497028514743e-06,0.0002574377504060976,0.00026148951292270795,0.00025789550272747874,0.0002606874913908541,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,evolution/one-step,2.9979011742398143e-05,7.705093594267964e-07,2.9416492907330394e-05,3.086450306000188e-05,2.9646005714312196e-05,3.0395996873266995e-05,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,finite-time/n-step/k-10,4.9645997933112085e-05,6.040063453838229e-07,4.9187743570655584e-05,5.085401062387973e-05,4.931249713990837e-05,5.0292001105844975e-05,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,finite-time/n-step/k-100,0.00025852049293462187,7.710041245445609e-07,0.00025776049005798995,0.00025928149261744693,0.00025793751410674304,0.000259145992458798,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,finite-time/observation/k-10,4.958349745720625e-05,6.664922693744302e-07,4.904199158772826e-05,5.053098720964044e-05,4.91874961880967e-05,5.0125003326684237e-05,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,finite-time/observation/k-100,0.00025912499404512346,1.021500793285668e-06,0.00025837551220320165,0.0002608225113363005,0.00025870850586215963,0.0002603539905976504,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,finite-time/step,8.544884622097015e-07,6.248592399060726e-08,8.022470865398645e-07,9.475043043494225e-07,8.329952834174037e-07,8.750066626816988e-07,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,hitting-probability/cold-all-states,4.3187508708797395e-05,1.0415096767246723e-06,4.231249477015808e-05,4.519774665823206e-05,4.256248939782381e-05,4.39017225289717e-05,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,hitting-time/cold-all-states,0.00011683351476676762,2.1874875528737903e-06,0.00011526050366228446,0.00011934375652344897,0.00011606249609030783,0.00011895799252670258,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,hitting/bounded/at-most/k-10,4.3854000978171825e-05,3.9550650399178267e-07,4.346925561549142e-05,4.425999941304326e-05,4.3541513150557876e-05,4.41250012954697e-05,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,hitting/bounded/at-most/k-100,0.000339520993293263,1.874504960142076e-06,0.00033744776010280475,0.000341249760822393,0.0003379160010808846,0.0003407500043977052,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,hitting/bounded/exact/k-10,4.2645493522286415e-05,6.465124897658825e-07,4.217724927002564e-05,4.32920060120523e-05,4.229199839755893e-05,4.3271007598377764e-05,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,hitting/bounded/exact/k-100,0.00034152049920521677,2.562999725341797e-06,0.00033736474870238453,0.00034359374694759026,0.00034016650170087814,0.00034329199115745723,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,hitting/bounded/greater-than/k-10,4.3916996219195426e-05,5.199981387704611e-07,4.330225056037307e-05,4.4364744098857045e-05,4.347898357082158e-05,4.4291489757597446e-05,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,hitting/bounded/greater-than/k-100,0.00034225048148073256,1.604013959877193e-06,0.0003378022520337254,0.00034353100636508316,0.00034054201387334615,0.0003432500088820234,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,occupation-matrix,0.000879395505762659,3.5625125747174025e-06,0.0008758119874983095,0.0008823232419672422,0.0008775420137681067,0.0008817977130092913,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,power/10,0.0003074374981224537,1.2499949662014842e-06,0.00030621850601164624,0.0003086145006818697,0.0003065625060116872,0.0003079790039919317,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,power/100,0.0003098954912275076,1.1039956007152796e-06,0.00030895824602339417,0.0003117912419838831,0.00030939601128920913,0.0003109789831796661,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,power/2,0.0003044994955416769,2.020999090746045e-06,0.0003026350022992119,0.00030639575561508536,0.0003034170076716691,0.00030558352591469884,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,return/bounded/k-10,4.3729000026360154e-05,9.784998837858438e-07,4.299997817724943e-05,4.4864493247587234e-05,4.310449003241956e-05,4.42500167991966e-05,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,return/bounded/k-100,0.0003378125111339614,3.7710124161094427e-06,0.00033539626747369766,0.00034715651418082416,0.000336061988491565,0.00034429150400683284,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,stationary,9.958349983207881e-05,1.7915008356794715e-06,9.802098793443292e-05,0.00010133324394701049,9.854200470726937e-05,0.00010041697532869875,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,structure/classes-cold,2.6249996153637767e-05,4.795001586899161e-07,2.58330037468113e-05,2.6749999960884452e-05,2.6020483346655965e-05,2.6604495360516012e-05,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,structure/classes-lifecycle,0.00042556249536573887,5.082983989268541e-06,0.0004219579859636724,0.00043112474668305367,0.0004225625016260892,0.00042964603853761223,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,structure/classes-warm/access,2.1777500078314914e-07,1.0083502274937835e-09,2.170292238588445e-07,2.2056252491893247e-07,2.1723088440921856e-07,2.1958124998491256e-07,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,structure/classes-warm/consumed,1.0007562508690172e-06,2.2833512048238137e-09,9.990281265345403e-07,1.0239594259473961e-06,9.9934579920955e-07,1.0126333509106188e-06,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,structure/irreducible-cold,2.5562505470588803e-05,5.2098766900599e-07,2.5062516215257347e-05,2.6031491870526224e-05,2.53544858423993e-05,2.579198917374015e-05,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,structure/irreducible-warm,2.2417495056288318e-07,8.312010322697621e-10,2.2364480028045365e-07,2.3475827692891473e-07,2.2374375112121925e-07,2.2922915086383002e-07,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,visits/bounded-expectation/k-10,1.9708488252945244e-05,2.7101486921310425e-07,1.9468505342956632e-05,2.0031504391226918e-05,1.9583007087931037e-05,1.9937506294809282e-05,30 +pydtmc,reducible-n0010-s31415,reducible,10,31415,visits/bounded-expectation/k-100,7.912502042017877e-05,8.130300557240844e-07,7.866701344028115e-05,8.053149213083088e-05,7.86875025369227e-05,8.024999988265336e-05,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,construction/public-consumed,0.000977896008407697,2.291490091010928e-06,0.0009759377498994581,0.0009808129907469265,0.0009770000033313408,0.0009797284874366596,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,evolution/k-10,6.456249684561044e-05,6.874761311337352e-07,6.40732396277599e-05,6.583350477740169e-05,6.420850695576519e-05,6.498000911960843e-05,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,evolution/k-100,0.0002820834924932569,3.7710124161094427e-06,0.00027748926368076354,0.00028500026382971555,0.0002799165085889399,0.00028462501359172165,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,evolution/one-step,4.227101453579962e-05,4.790053935721517e-07,4.2040985135827214e-05,4.3989486584905535e-05,4.2042010682052934e-05,4.347901267465204e-05,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,finite-time/n-step/k-10,6.345901056192815e-05,6.664922693744302e-07,6.293775368249044e-05,6.486474740086123e-05,6.306248542387038e-05,6.437499541789293e-05,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,finite-time/n-step/k-100,0.00027677051548380405,2.000480890274048e-06,0.0002746874961303547,0.00027870899066329,0.0002752500004135072,0.00027835401124320924,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,finite-time/observation/k-10,6.34789903415367e-05,8.959905244410038e-07,6.253126048250124e-05,6.406224565580487e-05,6.266601849347353e-05,6.395799573510885e-05,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,finite-time/observation/k-100,0.0002798744972096756,2.3335160221904516e-06,0.000276989238045644,0.00028187549469294026,0.00027758299256674945,0.0002812919992720708,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,finite-time/step,1.270498614758253e-06,6.2515027821064e-08,1.2090022210031748e-06,1.333013642579317e-06,1.2294913176447153e-06,1.333013642579317e-06,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,hitting-probability/cold-all-states,6.856249819975346e-05,1.250504283234477e-06,6.743700214428827e-05,7.079151691868901e-05,6.762502016499639e-05,6.958348967600614e-05,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,hitting-time/cold-all-states,0.00014733300486113876,1.6459962353110313e-06,0.0001466662433813326,0.00015108351362869143,0.00014668751100543886,0.00014983350411057472,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,hitting/bounded/at-most/k-10,6.058349390514195e-05,7.290072971954942e-07,5.966699245618656e-05,6.119824683992192e-05,5.989552300889045e-05,6.085399945732206e-05,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,hitting/bounded/at-most/k-100,0.000526624993653968,5.666996003128588e-06,0.0005217919824644923,0.0005327814797055908,0.000522833492141217,0.000531895988387987,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,hitting/bounded/exact/k-10,5.918751412536949e-05,1.167005393654108e-06,5.8291261666454375e-05,6.0750244301743805e-05,5.839600635226816e-05,6.03545195190236e-05,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,hitting/bounded/exact/k-100,0.0005209380033193156,9.16750286705792e-06,0.0005141457659192383,0.0005406152631621808,0.0005180419830139726,0.0005314794980222359,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,hitting/bounded/greater-than/k-10,6.112499977461994e-05,8.329807315021753e-07,6.026052142260596e-05,6.182248034747317e-05,6.03545195190236e-05,6.15829776506871e-05,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,hitting/bounded/greater-than/k-100,0.000545833507203497,8.082992280833423e-06,0.0005080315168015659,0.0005519374899449758,0.0005240840109763667,0.0005490414914675057,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,occupation-matrix,0.00488133350154385,2.5687506422400475e-05,0.004860031753196381,0.004988572749425657,0.004863541515078396,0.004933479009196162,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,power/10,0.0005237710138317198,2.6044872356578708e-06,0.0005202920001465827,0.0005253224881016649,0.0005218335136305541,0.0005250000103842467,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,power/100,0.0005305829981807619,3.062494215555489e-06,0.0005274477516650222,0.0005328645056579262,0.0005279579927446321,0.0005326460086507723,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,power/2,0.0005199169972911477,3.2295065466314554e-06,0.0005172082601347938,0.0005236769866314717,0.0005184789915801957,0.0005213540134718642,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,return/bounded/k-10,6.0770995332859457e-05,1.3750104699283838e-06,5.9603742556646466e-05,6.221875810297206e-05,5.9874990256503224e-05,6.166700040921569e-05,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,return/bounded/k-100,0.0005481459957081825,1.1249503586441278e-05,0.0005127190161147155,0.0005549380002776161,0.0005229996437265072,0.0005511665076483041,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,stationary,0.0002999585121870041,4.229528713040054e-06,0.0002973122464027256,0.0003070934908464551,0.00029847901896573603,0.00030380667049030303,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,structure/classes-cold,0.00011035399802494794,1.7704878700897098e-06,0.00010688574548112229,0.00011174999963259324,0.00010877099703066051,0.00011135400563944131,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,structure/classes-lifecycle,0.0011382920056348667,5.103502189740539e-06,0.0011339480115566403,0.0011436352579039522,0.0011355210008332506,0.0011417704954510555,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,structure/classes-warm/access,2.1769994928035885e-07,1.0145507985725992e-09,2.1685835017706268e-07,2.1913434975431302e-07,2.1715625043725595e-07,2.1806870063301175e-07,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,structure/classes-warm/consumed,1.7929374997038395e-06,2.0457999198697895e-09,1.7912948249431792e-06,1.7951072499272414e-06,1.7917667006258852e-06,1.7944708495633675e-06,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,structure/irreducible-cold,0.00011093799548689276,6.245099939405918e-07,0.00011022949183825403,0.00011148949852213264,0.00011052099580410868,0.00011120797717012465,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,structure/irreducible-warm,2.2420000022975727e-07,5.916503141634056e-10,2.2372919993358665e-07,2.248437507660128e-07,2.2382289898814634e-07,2.2457500017480924e-07,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,visits/bounded-expectation/k-10,3.181249485351145e-05,2.0848528947681189e-07,3.163550718454644e-05,3.213598392903805e-05,3.170798299834132e-05,3.187500988133252e-05,30 +pydtmc,reducible-n0025-s01729,reducible,25,1729,visits/bounded-expectation/k-100,9.4832998001948e-05,4.790053935721517e-07,9.441699512535706e-05,9.548949310556054e-05,9.445850446354598e-05,9.522949403617531e-05,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,construction/public-consumed,0.0009792705095605925,4.000496119260788e-06,0.0009766975126694888,0.0009847082474152558,0.0009780829859664664,0.0009835420059971511,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,evolution/k-10,6.516650319099426e-05,5.414913175627589e-07,6.484424375230446e-05,6.637523620156571e-05,6.497949652839452e-05,6.583301001228392e-05,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,evolution/k-100,0.0002844165137503296,5.645517376251519e-06,0.0002808439894579351,0.00029640649154316634,0.0002813125174725428,0.0002929170150309801,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,evolution/one-step,4.30410000262782e-05,8.960050763562322e-07,4.247875767759979e-05,4.431224806467071e-05,4.258297849446535e-05,4.4062515371479094e-05,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,finite-time/n-step/k-10,6.329150346573442e-05,6.869959179311991e-07,6.282249523792416e-05,6.460424629040062e-05,6.295900675468147e-05,6.383299478329718e-05,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,finite-time/n-step/k-100,0.0002784789976431057,2.688000677153468e-06,0.00027713551389751956,0.0002814057734212838,0.0002773749874904752,0.00028093805121898185,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,finite-time/observation/k-10,6.339550600387156e-05,5.00003807246685e-07,6.310475146165118e-05,6.426076288335025e-05,6.320849934127182e-05,6.385399319697171e-05,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,finite-time/observation/k-100,0.000279270505416207,1.8755090422928333e-06,0.00027657300961436704,0.00028054151334799826,0.0002774579916149378,0.0002802915114443749,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,finite-time/step,1.2500095181167126e-06,6.250047590583563e-08,1.2080126907676458e-06,1.333006366621703e-06,1.2080126907676458e-06,1.3124954421073198e-06,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,hitting-probability/cold-all-states,6.895800470374525e-05,1.2080126907676458e-06,6.795800436520949e-05,7.093702151905745e-05,6.816700624767691e-05,7.024951628409326e-05,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,hitting-time/cold-all-states,0.00014797899348195642,1.4789984561502934e-06,0.00014693749108118936,0.0001526039995951578,0.00014747949899174273,0.00015093749971129,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,hitting/bounded/at-most/k-10,6.0375488828867674e-05,6.045011105015874e-07,5.987499753246084e-05,6.138498429208994e-05,6.002100417390466e-05,6.0854494222439826e-05,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,hitting/bounded/at-most/k-100,0.00050945850671269,3.4794938983395696e-06,0.0005071874911664054,0.0005137914849910885,0.0005083124997327104,0.000512916492880322,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,hitting/bounded/exact/k-10,5.966599564999342e-05,1.1254887795075774e-06,5.85830130148679e-05,6.097951700212434e-05,5.875001079402864e-05,6.039549771230668e-05,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,hitting/bounded/exact/k-100,0.0005291045090416446,1.8999999156221747e-05,0.0005063224889454432,0.0005450939934235066,0.000511645499500446,0.0005376665067160502,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,hitting/bounded/greater-than/k-10,6.10209972364828e-05,1.4369870768859982e-06,5.981202411931008e-05,6.499975279439241e-05,6.00414932705462e-05,6.323472844087515e-05,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,hitting/bounded/greater-than/k-100,0.0005155005201231688,3.625522367656231e-06,0.0005132817532285117,0.0005515105076483451,0.0005145210161572322,0.0005335000023478642,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,occupation-matrix,0.004947166497004218,4.360449383966625e-05,0.0048876872679102235,0.004984479259292129,0.004918708989862353,0.004967458502505906,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,power/10,0.0005245624925009906,3.895984264090657e-06,0.0005210207600612193,0.0005284794824547134,0.0005222710024099797,0.0005268959939712659,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,power/100,0.0005323335062712431,2.562999725341797e-06,0.0005303332436596975,0.0005358017297112383,0.0005310419946908951,0.0005350835126591846,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,power/2,0.0005136880063218996,2.250511897727847e-06,0.000511343743710313,0.0005151770019438118,0.000511873435243615,0.000514896004460752,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,return/bounded/k-10,5.9646001318469644e-05,3.5398988984525204e-07,5.9374993725214154e-05,6.068749644327909e-05,5.941648851148784e-05,6.012499288772233e-05,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,return/bounded/k-100,0.0005154794926056638,1.7208483768627048e-05,0.0005014790003770031,0.0005586255065281875,0.000507416989421472,0.000529187498614192,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,stationary,0.0003022085002157837,4.687492037191987e-06,0.0002896979858633131,0.0003057705034734681,0.00029710400849580765,0.0003051664971280843,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,structure/classes-cold,0.00011583299783524126,2.9790098778903484e-06,0.00011297949095023796,0.00011869775335071608,0.00011510449985507876,0.00011839550279546529,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,structure/classes-lifecycle,0.0011340420023771003,9.770505130290985e-06,0.0011261245163041167,0.0012068437499692664,0.0011275830038357526,0.0011681736301397904,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,structure/classes-warm/access,2.1671459981007501e-07,4.813002306036536e-10,2.1622602653224023e-07,2.1714269969379528e-07,2.164584002457559e-07,2.1701670048059894e-07,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,structure/classes-warm/consumed,1.790233350766357e-06,1.9771003280765968e-09,1.7888155758555513e-06,1.7927187240275088e-06,1.7894958509714343e-06,1.7910062495502644e-06,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,structure/irreducible-cold,0.00010827099322341383,5.419860826805234e-07,0.00010739597928477451,0.00010865574586205184,0.0001077290071407333,0.00010854149877559394,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,structure/irreducible-warm,2.2433125122915953e-07,4.812522092834088e-10,2.2387297358363867e-07,2.2486670059151947e-07,2.23958348215092e-07,2.246333984658122e-07,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,visits/bounded-expectation/k-10,3.179148188792169e-05,2.0849984139204025e-07,3.156275488436222e-05,3.1958996260073036e-05,3.1666510039940476e-05,3.187500988133252e-05,30 +pydtmc,reducible-n0025-s02718,reducible,25,2718,visits/bounded-expectation/k-100,9.535400022286922e-05,6.67001586407423e-07,9.48332526604645e-05,9.645800309954211e-05,9.49374953052029e-05,9.58125019678846e-05,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,construction/public-consumed,0.00097795799956657,3.999506589025259e-06,0.0009750210010679439,0.0009829997579799965,0.0009765625,0.0009820830018725246,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,evolution/k-10,6.472899985965341e-05,7.289927452802658e-07,6.411450158338994e-05,6.573901191586629e-05,6.427100743167102e-05,6.545799260493368e-05,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,evolution/k-100,0.0002843959955498576,1.7294951248914003e-06,0.00028251000185264274,0.0002859170126612298,0.000283040979411453,0.00028558300982695073,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,evolution/one-step,4.410400288179517e-05,1.7709971871227026e-06,4.2458006646484137e-05,4.987475404050201e-05,4.279200220480561e-05,4.620800609700382e-05,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,finite-time/n-step/k-10,6.34165044175461e-05,7.085036486387253e-07,6.2791739765089e-05,6.474950350821018e-05,6.297949585132301e-05,6.410400965251029e-05,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,finite-time/n-step/k-100,0.0002751874999376014,2.5209883460775018e-06,0.0002730522392084822,0.000278229737887159,0.000273437486612238,0.0002763960073934868,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,finite-time/observation/k-10,6.389599002432078e-05,9.999930625781417e-07,6.345799920381978e-05,6.532275438075885e-05,6.358300706779118e-05,6.500000017695129e-05,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,finite-time/observation/k-100,0.0002796460030367598,1.250504283234477e-06,0.0002781664952635765,0.0002804684918373823,0.0002784999960567802,0.00028004200430586934,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,finite-time/step,1.2500095181167126e-06,6.250047590583563e-08,1.2079908628948033e-06,1.333006366621703e-06,1.2080126907676458e-06,1.2920063454657793e-06,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,hitting-probability/cold-all-states,7.158349035307765e-05,3.979483153671026e-06,6.762499106116593e-05,7.661450217710808e-05,6.775000656489283e-05,7.431200356222689e-05,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,hitting-time/cold-all-states,0.00015189599071163684,5.166497430764139e-06,0.00014777074829908088,0.00028194775950396433,0.00014943750284146518,0.00020366651006042957,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,hitting/bounded/at-most/k-10,6.258349458221346e-05,1.958003849722445e-06,6.121924525359645e-05,6.472850509453565e-05,6.137500167824328e-05,6.389599002432078e-05,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,hitting/bounded/at-most/k-100,0.0005576664989348501,2.8312511858530343e-05,0.0005341767391655594,0.0006120102407294326,0.0005480829859152436,0.0005839790101163089,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,hitting/bounded/exact/k-10,6.135400326456875e-05,9.999930625781417e-07,6.043776375008747e-05,6.236475019250065e-05,6.074999691918492e-05,6.210450374055654e-05,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,hitting/bounded/exact/k-100,0.0005062499985797331,3.687484422698617e-06,0.0005019064992666245,0.0005091037601232529,0.0005030209867982194,0.0005080209957668558,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,hitting/bounded/greater-than/k-10,6.131250120233744e-05,1.1459924280643463e-06,6.033349200151861e-05,6.3530751504004e-05,6.0582999140024185e-05,6.270852572924923e-05,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,hitting/bounded/greater-than/k-100,0.0005176664999453351,1.0749499779194593e-05,0.0005059577597421594,0.0005228959926171228,0.0005069170001661405,0.0005208960064919665,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,occupation-matrix,0.004950437491061166,0.0001244999875780195,0.0048411662428407,0.0052213232484064065,0.0048859375092433766,0.005049749990575947,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,power/10,0.0005911664920859039,6.156197923701257e-05,0.0005397807617555372,0.0006697505159536377,0.0005671249964507297,0.0006373954965965822,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,power/100,0.0005430210148915648,1.2312520993873477e-05,0.0005306042439769953,0.0005529479967663065,0.0005394375039031729,0.0005484589783009142,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,power/2,0.0005343539960449561,1.672899816185236e-05,0.0005201975072850473,0.0009982397605199367,0.0005230624956311658,0.0006879169959574938,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,return/bounded/k-10,6.168748950585723e-05,1.4164979802444577e-06,6.066699279472232e-05,6.377099634846672e-05,6.108345478423871e-05,6.308351294137537e-05,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,return/bounded/k-100,0.0005039794923504815,1.0562987881712615e-05,0.0004965627449564636,0.0005243954874458723,0.000498790992423892,0.0005152920057298616,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,stationary,0.0002999170101247728,3.3750111469998956e-06,0.0002968434928334318,0.00030331226298585534,0.000298083497909829,0.0003023750032298267,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,structure/classes-cold,0.0001251044886885211,8.229486411437392e-06,0.00011821874068118632,0.00013525025133276358,0.00012037550914101303,0.00013345849583856761,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,structure/classes-lifecycle,0.0011478750093374401,1.3791475794278085e-05,0.0011370097417966463,0.0011700314862537198,0.0011395420006010681,0.001161832973593846,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,structure/classes-warm/access,2.215958505985327e-07,3.239599755033849e-09,2.1922704909229652e-07,2.3018127540126442e-07,2.199479495175183e-07,2.2952500003157184e-07,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,structure/classes-warm/consumed,1.804299998912029e-06,1.1333299335092255e-08,1.7960281249543186e-06,1.833254150551511e-06,1.7965854014619254e-06,1.8159458006266502e-06,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,structure/irreducible-cold,0.00011514549260027707,2.9590155463665724e-06,0.00011171924415975809,0.00011755251762224361,0.00011347948748152703,0.00011672898835968226,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,structure/irreducible-warm,2.2547705011675134e-07,7.979499059729195e-10,2.2477285019704142e-07,2.2640000097453596e-07,2.250000005005859e-07,2.2616460191784426e-07,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,visits/bounded-expectation/k-10,3.277098585385829e-05,6.664922693744302e-07,3.2176518288906664e-05,3.422974987188354e-05,3.227098204661161e-05,3.3229530890821474e-05,30 +pydtmc,reducible-n0025-s31415,reducible,25,31415,visits/bounded-expectation/k-100,9.724999836180359e-05,2.4165055947378278e-06,9.570825204718858e-05,0.00010325025505153462,9.624999074731022e-05,0.00010045799717772752,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,construction/public-consumed,0.0030364374979399145,2.7041489374823868e-05,0.0030106665144558065,0.0030736567423446104,0.0030227722229028585,0.003044832992600277,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,evolution/k-10,8.852100290823728e-05,1.2495002010837197e-06,8.69370051077567e-05,8.921849075704813e-05,8.735449227970093e-05,8.881250687409192e-05,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,evolution/k-100,0.0003202285006409511,1.6034900909289718e-06,0.0003186040121363476,0.00032162525167223066,0.0003190415009157732,0.00032127050508279353,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,evolution/one-step,6.335451325867325e-05,5.83502696827054e-07,6.297898653429002e-05,6.453174137277529e-05,6.316648796200752e-05,6.406249340216163e-05,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,finite-time/n-step/k-10,8.64790054038167e-05,1.8544960767030716e-06,8.53020028444007e-05,9.160375338979065e-05,8.593749953433871e-05,8.970849739853293e-05,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,finite-time/n-step/k-100,0.000317083511617966,1.8959690351039171e-06,0.00031552024302072823,0.00031901073089102283,0.0003161249915137887,0.0003185829846188426,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,finite-time/observation/k-10,8.522899588569999e-05,7.289927452802658e-07,8.457248623017222e-05,8.59895080793649e-05,8.48339986987412e-05,8.585398609284312e-05,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,finite-time/observation/k-100,0.00031949950789567083,2.145985490642488e-06,0.00031713525095256045,0.0003210732465959154,0.0003176875034114346,0.0003207499976269901,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,finite-time/step,1.5829864423722029e-06,4.20113792642951e-08,1.541258825454861e-06,1.6565099940635264e-06,1.5419936971738935e-06,1.604494173079729e-06,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,hitting-probability/cold-all-states,0.0001552500034449622,2.6040070224553347e-06,0.0001525939951534383,0.00015764575073262677,0.00015360399265773594,0.00015718750364612788,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,hitting-time/cold-all-states,0.00024354198831133544,1.7499987734481692e-06,0.0002420102318865247,0.00024676023895153776,0.0002424374979455024,0.0002447920269332826,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,hitting/bounded/at-most/k-10,0.00015677099872846156,2.28749995585531e-05,0.0001286979895667173,0.00016602076357230544,0.00013389599916990846,0.00016260400298051536,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,hitting/bounded/at-most/k-100,0.0007908120023785159,2.937493263743818e-06,0.0007855837538954802,0.0007931767468107864,0.0007881244964664802,0.0007922704971861094,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,hitting/bounded/exact/k-10,8.710450492799282e-05,4.5850174501538277e-07,8.663551125209779e-05,8.752126450417563e-05,8.677050936967134e-05,8.73749959282577e-05,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,hitting/bounded/exact/k-100,0.0007985830015968531,1.0146017302758992e-05,0.0007901767457951792,0.0008257604858954437,0.0007936664915177971,0.0008096664969343692,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,hitting/bounded/greater-than/k-10,8.922899723984301e-05,8.129863999783993e-07,8.82285094121471e-05,8.993800292955711e-05,8.860349771566689e-05,8.968751353677362e-05,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,hitting/bounded/greater-than/k-100,0.000791062499047257,5.437483196146786e-06,0.0007853232600609772,0.000796041487774346,0.0007863540085963905,0.0007944160024635494,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,occupation-matrix,0.02143649999925401,0.0009460415021749213,0.020511448004981503,0.022330020503432024,0.020600312505848706,0.022091916005592793,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,power/10,0.001240625002537854,9.958501323126256e-06,0.0012315412604948506,0.0012560207542264834,0.0012333329941611737,0.0012488539941841736,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,power/100,0.001264041507965885,1.2478994904085994e-05,0.001251218760444317,0.001275426744541619,0.0012538330047391355,0.0012687499984167516,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,power/2,0.0011185414914507419,4.333487595431507e-06,0.001114103761210572,0.001122478992328979,0.0011149999918416142,0.0011212289973627776,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,return/bounded/k-10,8.677100413478911e-05,9.789946489036083e-07,8.626048656878993e-05,8.833350148051977e-05,8.637500286567956e-05,8.766649989411235e-05,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,return/bounded/k-100,0.0007847704982850701,1.022899232339114e-05,0.0007795937490300275,0.0008129374982672743,0.0007804164924891666,0.0008060624968493357,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,stationary,0.000852083001518622,1.1374489986337721e-05,0.0008404895052080974,0.0008621769957244396,0.000841017392303911,0.000860333486343734,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,structure/classes-cold,0.0003306875005364418,1.9584986148402095e-06,0.00032796923915157095,0.0003316454967716709,0.0003288750012870878,0.00033154150878544897,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,structure/classes-lifecycle,0.0034258744854014367,1.2771008186973631e-05,0.0034153232554672286,0.0034388859930913895,0.0034163535019615665,0.003436999992118217,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,structure/classes-warm/access,2.1681250073015692e-07,6.521018804051129e-10,2.1631044946843757e-07,2.1811352416989394e-07,2.165229496313259e-07,2.1766874997410925e-07,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,structure/classes-warm/consumed,3.0829604496830143e-06,4.7812500270083885e-09,3.079744800925255e-06,3.101987502304837e-06,3.0804270994849504e-06,3.098414601117838e-06,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,structure/irreducible-cold,0.0003291460016043857,4.958492354489863e-06,0.0003186879985150881,0.0003333752538310364,0.0003243109331378946,0.0003331039915792644,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,structure/irreducible-warm,2.2766875044908373e-07,7.667011232115137e-10,2.2708332471665926e-07,2.3927502479637044e-07,2.2734169906470926e-07,2.33352099894546e-07,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,visits/bounded-expectation/k-10,5.229150701779872e-05,4.795001586899161e-07,5.195824633119628e-05,5.3406518418341875e-05,5.199998850002885e-05,5.3187497542239726e-05,30 +pydtmc,reducible-n0050-s01729,reducible,50,1729,visits/bounded-expectation/k-100,0.00013252050848677754,1.5415134839713573e-06,0.00013049974950263277,0.00013397925067692995,0.00013104200479574502,0.0001336249988526106,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,construction/public-consumed,0.003020957999979146,6.040980224497616e-06,0.0030147920188028365,0.00302555149391992,0.0030161245085764676,0.0030239585030358285,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,evolution/k-10,8.856250497046858e-05,1.604013959877193e-06,8.714574505575001e-05,9.086499630939215e-05,8.741702185943723e-05,8.916700608097017e-05,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,evolution/k-100,0.0003195000026607886,1.4795077731832862e-06,0.0003181664797011763,0.0003210417489754036,0.00031868749647401273,0.0003202085063094273,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,evolution/one-step,6.920800660736859e-05,6.561996997334063e-06,6.404201121767983e-05,0.00010353149991715327,6.493749970104545e-05,8.091698691714555e-05,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,finite-time/n-step/k-10,8.779150084592402e-05,1.5419936971738935e-06,8.642701141070575e-05,8.935423829825595e-05,8.666649227961898e-05,8.870850433595479e-05,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,finite-time/n-step/k-100,0.00031783300801180303,1.6464910004287958e-06,0.0003165625166730024,0.0003198537524440326,0.0003170415002387017,0.00031939600012265146,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,finite-time/observation/k-10,8.597949636168778e-05,1.104010152630508e-06,8.486500155413523e-05,8.692726260051131e-05,8.506250742357224e-05,8.633348625153303e-05,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,finite-time/observation/k-100,0.0003210415015928447,7.103997631929815e-06,0.00031470823159907013,0.0003704997434397228,0.000316332996590063,0.00033650000113993883,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,finite-time/step,1.811989932321012e-06,3.1197851058095694e-07,1.583983248565346e-06,5.5102427722886205e-06,1.6249832697212696e-06,3.312001354061067e-06,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,hitting-probability/cold-all-states,0.000184062504558824,2.164598845411092e-05,0.00016519825294381008,0.00021054175158496946,0.0001697919942671433,0.00020662500173784792,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,hitting-time/cold-all-states,0.00024854201183188707,4.270987119525671e-06,0.00024485452013323084,0.0002547289986978285,0.0002463749988237396,0.0002508750185370445,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,hitting/bounded/at-most/k-10,8.872948819771409e-05,8.335046004503965e-07,8.778124902164564e-05,8.941673149820417e-05,8.808349957689643e-05,8.924998110160232e-05,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,hitting/bounded/at-most/k-100,0.0007920415082480758,6.14600139670074e-06,0.0007729160206508823,0.0007956877525430173,0.0007864579965826124,0.0007950625149533153,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,hitting/bounded/exact/k-10,8.712499402463436e-05,9.169743862003088e-07,8.620801963843405e-05,8.794775203568861e-05,8.637498831376433e-05,8.785449608694762e-05,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,hitting/bounded/exact/k-100,0.0007908330007921904,3.68799373973161e-06,0.0007845729996915907,0.0007936872498248704,0.000787270488217473,0.0007918750052340329,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,hitting/bounded/greater-than/k-10,8.850000449456275e-05,7.500057108700275e-07,8.784424426266924e-05,8.943748980527744e-05,8.808349957689643e-05,8.910401083994657e-05,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,hitting/bounded/greater-than/k-100,0.0008014795021153986,8.062503184191883e-06,0.0007949794962769374,0.0008478652525809593,0.0007967915153130889,0.0008229374943766743,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,occupation-matrix,0.020464541492401622,0.00010306248441338539,0.020369124511489645,0.02058370800659759,0.02039944756543264,0.020543021004414186,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,power/10,0.0012381249980535358,1.6291480278596282e-05,0.0012319064990151674,0.0014208334832801484,0.0012326670112088323,0.0013824165071127936,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,power/100,0.0012549789971671999,8.312505087815225e-06,0.0012514577392721549,0.0012666142647503875,0.0012524790217867121,0.0012618539913091809,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,power/2,0.0011833750031655654,6.593798752874136e-05,0.0011373542656656355,0.0013540107684093527,0.0011746874952223152,0.0012509375083027408,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,return/bounded/k-10,8.697950397618115e-05,8.329952834174037e-07,8.57502527651377e-05,8.744824299355969e-05,8.63960012793541e-05,8.724999497644603e-05,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,return/bounded/k-100,0.0008517709939042106,5.791650619357824e-05,0.0007959169961395673,0.0009093230037251487,0.0008028334996197373,0.0008750414854148403,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,stationary,0.0008264375064754859,5.874986527487636e-06,0.0008168957429006696,0.0008305629817186855,0.0008200414886232466,0.0008300835033878684,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,structure/classes-cold,0.00033543699828442186,1.3124954421073198e-06,0.00033312474988633767,0.00033619750320212916,0.0003342085110489279,0.0003360625123605132,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,structure/classes-lifecycle,0.0034661459940252826,4.466649261303246e-05,0.0034355107418377884,0.0036121360026299953,0.0034501460031606257,0.0035777289886027575,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,structure/classes-warm/access,2.176396010327153e-07,6.624992238357684e-10,2.1670834976248443e-07,2.1804270072607321e-07,2.1689999848604202e-07,2.1797499939566477e-07,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,structure/classes-warm/consumed,3.0965624988311903e-06,1.0568750440142976e-08,3.0870510490785816e-06,3.109898925322341e-06,3.0933208006899805e-06,3.1055437997565604e-06,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,structure/irreducible-cold,0.00033545849146321416,8.125003660097718e-06,0.0003250622539781034,0.0003410832359804772,0.0003311249893158674,0.00033887499012053013,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,structure/irreducible-warm,2.2832289978396147e-07,2.0145511371083573e-09,2.2640942479483783e-07,2.311760254087858e-07,2.2721874993294478e-07,2.3040409723762423e-07,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,visits/bounded-expectation/k-10,5.224999040365219e-05,3.335007932037115e-07,5.196851270738989e-05,5.2572766435332596e-05,5.204150511417538e-05,5.235451681073755e-05,30 +pydtmc,reducible-n0050-s02718,reducible,50,2718,visits/bounded-expectation/k-100,0.00013806301285512745,7.68802419770509e-06,0.00013137525820638984,0.00017037475481629372,0.00013420850154943764,0.00014747949899174273,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,construction/public-consumed,0.003023833007318899,1.3041499187238514e-05,0.0030084162499406375,0.003034676999959629,0.0030151664977893233,0.003031500003999099,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,evolution/k-10,8.81669984664768e-05,7.089984137564898e-07,8.75732657732442e-05,8.958325634011999e-05,8.770899148657918e-05,8.88124923221767e-05,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,evolution/k-100,0.0003250414883950725,1.9790022633969784e-06,0.00032288524380419403,0.00032653148809913546,0.0003232704912079498,0.0003259170043747872,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,evolution/one-step,6.3521001720801e-05,8.960050763562322e-07,6.28855123068206e-05,6.49897483526729e-05,6.302147812675685e-05,6.416699034161866e-05,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,finite-time/n-step/k-10,8.56875121826306e-05,1.2289820006117225e-06,8.505151345161721e-05,8.741674537304789e-05,8.533349318895489e-05,8.691649418324232e-05,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,finite-time/n-step/k-100,0.0003146249946439639,1.9165017874911427e-06,0.0003133232530672103,0.0003170212366967462,0.00031364599999506027,0.0003159795160172507,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,finite-time/observation/k-10,8.664549386594445e-05,1.4995166566222906e-06,8.518773393006995e-05,8.879150846041739e-05,8.539600821677595e-05,8.729149703867733e-05,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,finite-time/observation/k-100,0.0003172919969074428,1.5420082490891218e-06,0.0003160312626278028,0.00031954149017110467,0.000316478496461059,0.0003186670073773712,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,finite-time/step,1.5830155462026596e-06,6.250047590583563e-08,1.5420082490891218e-06,1.7087513697333634e-06,1.5420082490891218e-06,1.6664998838678002e-06,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,hitting-probability/cold-all-states,0.00015368750609923154,1.7705024220049381e-06,0.00015212499420158565,0.00015615649317624047,0.00015266700938809663,0.0001551050412672339,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,hitting-time/cold-all-states,0.00024422949354629964,1.979497028514743e-06,0.00024268749257316813,0.0002471564948791638,0.0002431670145597309,0.00024641648633405566,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,hitting/bounded/at-most/k-10,8.841700037010014e-05,8.119968697428703e-07,8.756249735597521e-05,8.917674131225795e-05,8.781149190326686e-05,8.89999937498942e-05,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,hitting/bounded/at-most/k-100,0.0007925624813651666,4.18750278186053e-06,0.0007566252461401746,0.0007947810008772649,0.0007742084853816777,0.000793562998296693,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,hitting/bounded/exact/k-10,8.70829971972853e-05,5.619949661195278e-07,8.670899114804342e-05,8.788500417722389e-05,8.675051503814757e-05,8.774950401857495e-05,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,hitting/bounded/exact/k-100,0.0007930629944894463,2.624496119096875e-06,0.0007910627682576887,0.0007958854839671403,0.0007915835012681782,0.0007948124984977767,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,hitting/bounded/greater-than/k-10,8.779201016295701e-05,4.795001586899161e-07,8.73434983077459e-05,8.830175647744909e-05,8.754149894230068e-05,8.810449799057096e-05,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,hitting/bounded/greater-than/k-100,0.0007963959797052667,4.2504980228841305e-06,0.0007934889945317991,0.0008018227454158477,0.0007942084921523929,0.0008001670066732913,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,occupation-matrix,0.02022481249878183,0.00021258299238979816,0.020008302250062115,0.020382489477924537,0.020097202278338954,0.020327750011347234,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,power/10,0.0012473125098040327,1.5875004464760423e-05,0.001237958247656934,0.0012884477619081736,0.0012385834997985512,0.0012693955068243667,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,power/100,0.0012409789924276993,8.292001439258456e-06,0.001234415998624172,0.001249156252015382,0.0012382710119709373,0.0012434589734766632,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,power/2,0.0011236249993089586,7.5004936661571264e-06,0.0011200939989066683,0.0011422600000514649,0.0011203960020793602,0.0011383960081730038,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,return/bounded/k-10,8.610449731349945e-05,5.629990482702851e-07,8.582325972383842e-05,8.698949386598542e-05,8.591701043769717e-05,8.683350461069494e-05,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,return/bounded/k-100,0.0007851874979678541,3.8124999264255166e-06,0.0007831874972907826,0.0008057710001594387,0.000783811992732808,0.000788186996942386,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,stationary,0.0008250829996541142,3.937515430152416e-06,0.0008201352538890205,0.000828155993076507,0.0008240005117841065,0.0008267710072686896,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,structure/classes-cold,0.000324124499456957,5.541995051316917e-06,0.00031873926491243765,0.0003296670038253069,0.00032087499857880175,0.00032804151123855263,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,structure/classes-lifecycle,0.0034314795047976077,1.4708508388139307e-05,0.0034181455048383214,0.0034469579841243103,0.0034252914920216426,0.003441061999183148,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,structure/classes-warm/access,2.1683329978259282e-07,1.2562493793666396e-09,2.1562294932664372e-07,2.1821462432853876e-07,2.1594999998342245e-07,2.1783124975627288e-07,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,structure/classes-warm/consumed,3.075918748800177e-06,6.495849811471899e-09,3.0726655997568744e-06,3.101883350609569e-06,3.073233301984146e-06,3.1010666498332283e-06,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,structure/irreducible-cold,0.00032654199458193034,6.6250067902728915e-06,0.0003202812440576963,0.00033325000549666584,0.0003225624968763441,0.00033264601370319724,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,structure/irreducible-warm,2.2538124903803692e-07,5.145993782207411e-10,2.2499062470160426e-07,2.42953125416534e-07,2.2503334912471472e-07,2.3385624954244123e-07,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,visits/bounded-expectation/k-10,5.1895505748689175e-05,3.7449353840202093e-07,5.151051300344989e-05,5.220876482781023e-05,5.1645998610183597e-05,5.210403251112439e-05,30 +pydtmc,reducible-n0050-s31415,reducible,50,31415,visits/bounded-expectation/k-100,0.00012839550618082285,7.084890967234969e-07,0.0001280942597077228,0.00013366674829740077,0.00012816651724278927,0.00013168698933441192,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,construction/public-consumed,0.011341562494635582,9.368750033900142e-05,0.0112973122522817,0.011442531758802943,0.011319625016767532,0.011391353502403945,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,evolution/k-10,0.00013945849786978215,1.791995600797236e-06,0.0001380417525069788,0.00014207300409907475,0.00013843749184161425,0.00014070850738789886,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,evolution/k-100,0.00044241650903131813,3.6459823604673147e-06,0.000439614501374308,0.00044806224468629807,0.00044022851216141135,0.0004461249918676913,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,evolution/one-step,0.0001092080055968836,1.5830009942874312e-06,0.00010743750317487866,0.00011037499643862247,0.0001076460030162707,0.00010966649278998375,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,finite-time/n-step/k-10,0.00013737549306824803,1.6669800970703363e-06,0.0001356667635263875,0.00013842673797626048,0.000136270493385382,0.00013804150512441993,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,finite-time/n-step/k-100,0.0004387085064081475,4.687506589107215e-06,0.0004339062579674646,0.00044141676335129887,0.0004344170156400651,0.0004404585051815957,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,finite-time/observation/k-10,0.00013712501095142215,1.3960234355181456e-06,0.0001360105161438696,0.00013868726091459394,0.00013614649651572108,0.0001381255133310333,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,finite-time/observation/k-100,0.0004401459882501513,3.479508450254798e-06,0.000436333502875641,0.0004429794935276732,0.0004369580128695816,0.0004413330170791596,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,finite-time/step,2.9585062293335795e-06,1.2449163477867842e-07,2.874992787837982e-06,3.2292737159878016e-06,2.91600008495152e-06,3.082997864112258e-06,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,hitting-probability/cold-all-states,0.0006130414985818788,2.708504325710237e-06,0.0006110212416388094,0.000616771008935757,0.0006117500015534461,0.0006156175109936156,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,hitting-time/cold-all-states,0.0007288745109690353,3.4575059544295073e-06,0.0007258957484737039,0.0007335735208471306,0.0007265835010912269,0.0007302914891624823,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,hitting/bounded/at-most/k-10,0.00018068750796373934,9.789946489036083e-07,0.00018001099670073017,0.00018261399964103475,0.00018041649309452623,0.00018174998695030808,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,hitting/bounded/at-most/k-100,0.001722041517496109,6.541522452607751e-06,0.0017165205063065514,0.0017360730053042062,0.0017184585012728348,0.0017256249848287553,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,hitting/bounded/exact/k-10,0.0001791669928934425,1.5209807315841317e-06,0.00017794773884816095,0.00018095847917720675,0.00017852098972070962,0.00018064551113639027,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,hitting/bounded/exact/k-100,0.0017280629981542006,4.646499291993678e-06,0.0017233957478310913,0.001732572760374751,0.0017246249772142619,0.001731833501253277,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,hitting/bounded/greater-than/k-10,0.00018139548774342984,1.3329845387488604e-06,0.00018026050383923575,0.00018359375098953024,0.0001803960039978847,0.00018250000721309334,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,hitting/bounded/greater-than/k-100,0.0017230415105586872,6.521004252135754e-06,0.001716301754640881,0.001728375253151171,0.001719624488032423,0.0017266459908569232,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,occupation-matrix,0.08726600000227336,0.00025043750065378845,0.08694813524925848,0.08747176074393792,0.08704666700214148,0.08740447901072912,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,power/10,0.004125270992517471,2.8395996196195483e-05,0.0041068650025408715,0.004190354251477402,0.004113333998247981,0.004177458496997133,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,power/100,0.004145396014791913,3.9645994547754526e-05,0.0041131977559416555,0.0042030105032608844,0.004115999996429309,0.004167999999481253,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,power/2,0.003510562499286607,4.864600487053394e-05,0.0034625420012162067,0.0035554895002860576,0.003494749980745837,0.0035288750077597797,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,return/bounded/k-10,0.00017660448793321848,1.6669800970703363e-06,0.0001756249985191971,0.00018037448899121955,0.0001757709978846833,0.0001790209935279563,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,return/bounded/k-100,0.0016915620071813464,4.374509444460273e-06,0.0016868335005710833,0.0016948544871411286,0.0016900835034903139,0.0016933959996094927,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,stationary,0.0028423960029613227,3.8083497202023864e-05,0.0028154687606729567,0.0029290212405612692,0.0028210210002725944,0.0029173954972065985,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,structure/classes-cold,0.0011736040032701567,9.208510164171457e-06,0.0011624267572187819,0.001181375002488494,0.0011683329939842224,0.0011797290062531829,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,structure/classes-lifecycle,0.012804229496396147,0.00012425049499142915,0.012667260751186404,0.012850625236751512,0.012679979001404718,0.012825833502574824,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,structure/classes-warm/access,2.1645624947268517e-07,5.833499017171509e-10,2.1569584860117177e-07,2.170042265788652e-07,2.16033348988276e-07,2.1682914957636966e-07,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,structure/classes-warm/consumed,5.631381248531398e-06,8.795849862508136e-09,5.625648974819342e-06,5.750033375807107e-06,5.626622900308575e-06,5.705252693223883e-06,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,structure/irreducible-cold,0.0011682079930324107,1.983299443963915e-05,0.0011574162490433082,0.0011952499917242676,0.001164291490567848,0.0011928340245503932,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,structure/irreducible-warm,2.2370000078808514e-07,1.095850893761939e-09,2.2290839988272638e-07,2.251177495054435e-07,2.2319375129882245e-07,2.2475834848592057e-07,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,visits/bounded-expectation/k-10,9.714599582366645e-05,1.1039956007152796e-06,9.62707563303411e-05,9.901076555252075e-05,9.660400974098593e-05,9.781353692233096e-05,30 +pydtmc,reducible-n0100-s01729,reducible,100,1729,visits/bounded-expectation/k-100,0.00022616649221163243,1.062522642314434e-06,0.00022538525081472471,0.0002272600177093409,0.000225499999942258,0.00022697901295032352,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,construction/public-consumed,0.011486125498777255,0.00021877149993088096,0.011314093491819222,0.011908635489817243,0.011375792004400864,0.011596104013733566,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,evolution/k-10,0.00015920850273687392,1.756299752742052e-05,0.00014697873848490417,0.00019181199604645371,0.00015097948198672384,0.00017935399955604225,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,evolution/k-100,0.000459853996289894,1.8437000107951462e-05,0.00044475025788415223,0.00048809325380716473,0.00044668751070275903,0.0004795415006810799,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,evolution/one-step,0.0001266665058210492,1.631199847906828e-05,0.00011284375796094537,0.0001446250025765039,0.00011541650746949017,0.00014158349949866533,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,finite-time/n-step/k-10,0.000150020990986377,1.36044982355088e-05,0.00014183350140228868,0.00019244750001234934,0.0001440210035070777,0.0001862084900494665,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,finite-time/n-step/k-100,0.0004974165058229119,4.475000605452806e-05,0.0004587812509271316,0.0005443017435027286,0.00046893749095033854,0.000537354004336521,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,finite-time/observation/k-10,0.00016218751261476427,1.3896031305193901e-05,0.00015142650227062404,0.00020247924840077758,0.00015302050451282412,0.00018883349548559636,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,finite-time/observation/k-100,0.0004682709986809641,2.191650855820626e-05,0.00044955201155971736,0.0004956664997735061,0.00045389549632091075,0.0004883540095761418,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,finite-time/step,7.896000170148909e-06,2.97899532597512e-06,4.749737854581326e-06,9.97923780232668e-06,5.374997272156179e-06,9.3334965640679e-06,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,hitting-probability/cold-all-states,0.0006818544934503734,4.170800093561411e-05,0.0006317807346931659,0.0007097082489053719,0.0006395629898179322,0.0007049164996715263,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,hitting-time/cold-all-states,0.0007979160000104457,5.55824808543548e-05,0.0007491459982702509,0.000864218978676945,0.0007622920093126595,0.0008365834946744144,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,hitting/bounded/at-most/k-10,0.00018683349480852485,7.520982762798667e-06,0.0001818957389332354,0.0002279687614645809,0.00018283299868926406,0.00020158350525889546,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,hitting/bounded/at-most/k-100,0.0017687914951238781,2.5374494725838304e-05,0.0017421460070181638,0.001784905733074993,0.0017517920059617609,0.001777375495294109,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,hitting/bounded/exact/k-10,0.00020847900304943323,2.158299321308732e-05,0.0001878752518678084,0.00023572974896524101,0.00019481249910313636,0.00022175000049173832,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,hitting/bounded/exact/k-100,0.0017970625049201772,6.733351619914174e-05,0.0017428332430426963,0.0018737397622317076,0.0017567495087860152,0.0018654375016922131,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,hitting/bounded/greater-than/k-10,0.00022139601060189307,3.0687995604239404e-05,0.00019258326210547239,0.0002625624983920716,0.00020141650747973472,0.00025208399165421724,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,hitting/bounded/greater-than/k-100,0.0017315834993496537,9.416500688530505e-06,0.0017237287465832196,0.0017421770025976002,0.0017260829918086529,0.0017393955058651045,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,occupation-matrix,0.08921160400495864,0.0008739370096009225,0.08873135373869445,0.09095203125616536,0.08882850050576963,0.0904288540041307,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,power/10,0.004264603499905206,8.547899778932333e-05,0.004237354012730066,0.004372489245724864,0.004242957991664298,0.0043587079853750765,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,power/100,0.004290416502044536,5.0604023272171617e-05,0.00424087524152128,0.004386771499412134,0.0042533129890216514,0.004321645988966338,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,power/2,0.0036062709987163544,0.00012072949903085828,0.003476093741483055,0.003708635500515811,0.0034922709892271087,0.0036575830017682165,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,return/bounded/k-10,0.00022574998729396611,2.4438006221316755e-05,0.00020537449017865583,0.00025130250287475064,0.0002146875049220398,0.00023731250257696956,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,return/bounded/k-100,0.001721166496281512,2.4812485207803547e-05,0.0016983852547127753,0.001750020994222723,0.0017056244978448376,0.0017438129871152341,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,stationary,0.0028911460103699937,4.441698547452688e-05,0.0028575729884323664,0.002974385250126943,0.002864469115593238,0.002948812485556118,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,structure/classes-cold,0.0012256454938324168,2.166649210266769e-05,0.0012009372294414788,0.0012430727656465024,0.0012069795047864318,0.001238125012605451,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,structure/classes-lifecycle,0.012997812504181638,0.00025014550192281604,0.012739125493681058,0.013141927498509176,0.012825583515223116,0.013094291993184015,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,structure/classes-warm/access,2.1705830004066228e-07,5.854002665728193e-10,2.1655420059687458e-07,2.1781462419312447e-07,2.1678750053979457e-07,2.1757710055680945e-07,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,structure/classes-warm/consumed,5.68290004885057e-06,2.9589550103992033e-08,5.656507324601989e-06,5.733421848708531e-06,5.667312500008848e-06,5.699166699196212e-06,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,structure/irreducible-cold,0.0012021874863421544,1.375000283587724e-05,0.001187093512271531,0.0012136767472838983,0.0011934380017919466,0.0012111665128031746,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,structure/irreducible-warm,2.4274165043607354e-07,4.097900819033396e-09,2.3070725001161918e-07,2.464885503286496e-07,2.3899999796412884e-07,2.4402089766226707e-07,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,visits/bounded-expectation/k-10,9.852049697656184e-05,2.4790060706436634e-06,9.645848331274465e-05,0.00010268774349242449,9.660400974098593e-05,0.0001007499813567847,30 +pydtmc,reducible-n0100-s02718,reducible,100,2718,visits/bounded-expectation/k-100,0.00024197901075240225,1.1395997717045248e-05,0.00023085375869413838,0.00025379174621775746,0.00023291702382266521,0.00024904201563913375,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,construction/public-consumed,0.011360625008819625,0.0001143749977927655,0.011278593992756214,0.011491062767163385,0.011323895989335142,0.011460288342277634,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,evolution/k-10,0.0001397494925186038,1.8749997252598405e-06,0.00013821850734530017,0.00014268726226873696,0.00013870850671082735,0.0001417500025127083,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,evolution/k-100,0.00044479100324679166,5.832014721818268e-06,0.00043925049249082804,0.00045031252375338227,0.00044160400284454226,0.00044785400677938014,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,evolution/one-step,0.00010929199925158173,2.5004992494359612e-06,0.00010813550761668012,0.00011278175952611491,0.00010877050226554275,0.00011141650611534715,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,finite-time/n-step/k-10,0.00013802049215883017,1.6039848560467362e-06,0.00013717649562750012,0.00014483374980045483,0.00013741650036536157,0.00013960452706669456,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,finite-time/n-step/k-100,0.00044256250839680433,6.104004569351673e-06,0.00043762473796959966,0.00046362501598196104,0.00044170801993459463,0.0004520625079749152,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,finite-time/observation/k-10,0.00019635401258710772,2.341700019314885e-05,0.00017551099881529808,0.00022122924565337598,0.00017702049808576703,0.00021112500689923763,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,finite-time/observation/k-100,0.0004384165076771751,3.875000402331352e-06,0.00043508275120984763,0.00044312475802144036,0.0004355830023996532,0.00044164550490677357,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,finite-time/step,3.104505594819784e-06,2.2949825506657362e-07,2.9999937396496534e-06,3.7399950088001788e-06,3.0204973882064223e-06,3.2910029403865337e-06,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,hitting-probability/cold-all-states,0.0006131879927124828,2.687476808205247e-06,0.0006106669970904477,0.00061703150277026,0.0006108508536271984,0.0006154580041766167,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,hitting-time/cold-all-states,0.0007305420003831387,3.937500878237188e-06,0.0007280942518264055,0.0007356147398240864,0.000729311999748461,0.0007336249982472509,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,hitting/bounded/at-most/k-10,0.00018162450578529388,1.2079981388524175e-06,0.00018083275790559128,0.00018323974654776976,0.00018127099610865116,0.0001828954991651699,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,hitting/bounded/at-most/k-100,0.0017270625103265047,5.916488589718938e-06,0.0017208435019711033,0.001732260236167349,0.0017248329822905362,0.0017296664882451296,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,hitting/bounded/exact/k-10,0.00017981250130105764,1.604013959877193e-06,0.0001781877363100648,0.00018107348296325654,0.00017868750728666782,0.0001806459913495928,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,hitting/bounded/exact/k-100,0.0017298335005762056,5.166511982679367e-06,0.001726948241412174,0.0017369584893458523,0.0017280835018027574,0.0017356875032419339,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,hitting/bounded/greater-than/k-10,0.0001837499876273796,2.5000044843181968e-06,0.00018248924607178196,0.00019792724924627692,0.00018283299868926406,0.00018862499564420432,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,hitting/bounded/greater-than/k-100,0.0017317505116807297,4.938017809763551e-06,0.001728208502754569,0.0017379579949192703,0.0017294999997830018,0.0017352709983242676,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,occupation-matrix,0.0873772915074369,0.0002869370218832046,0.08710008322668727,0.08772346850309987,0.0872337500040885,0.0875558124971576,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,power/10,0.004109979490749538,3.856299736071378e-05,0.0040884272384573705,0.004179260242381133,0.004091124981641769,0.00414847899810411,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,power/100,0.004126396015635692,4.681247810367495e-05,0.004085447500983719,0.004176655755145475,0.0040929999959189445,0.004162646000622772,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,power/2,0.0035224165039835498,5.5854005040600896e-05,0.0034704692370723933,0.0035764167478191666,0.0034859169827541336,0.0035639999841805547,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,return/bounded/k-10,0.00017879150982480496,3.6040146369487047e-06,0.00017667725478531793,0.00024155199935194105,0.00017689600645098835,0.00020952099293936044,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,return/bounded/k-100,0.0016993125027511269,5.062509444542229e-06,0.0016955417595454492,0.0017094375070882961,0.0016967499977909029,0.0017037504876498133,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,stationary,0.002841832989361137,1.3728989870287478e-05,0.0028279894977458753,0.0028546872490551323,0.0028287494933465496,0.00284968750202097,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,structure/classes-cold,0.0011815829784609377,6.6250067902728915e-06,0.0011628640058916062,0.0011851564995595254,0.0011759584886021912,0.0011839790095109493,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,structure/classes-lifecycle,0.01265045850595925,8.64790054038167e-05,0.012590031015861314,0.012773916991136502,0.012605020485352725,0.012729333495371975,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,structure/classes-warm/access,2.1885000023758038e-07,1.6582998796366219e-09,2.1679167621186935e-07,2.204197757237125e-07,2.1756459900643677e-07,2.2002500045346095e-07,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,structure/classes-warm/consumed,5.659852099779528e-06,6.88544969307236e-09,5.6522030739870385e-06,5.664674999570707e-06,5.654193699592724e-06,5.663072899915278e-06,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,structure/irreducible-cold,0.001239708493812941,4.441649070940912e-05,0.0011646560160443187,0.0012658437553909607,0.001209497224772349,0.0012608749966602772,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,structure/irreducible-warm,2.2585629922104998e-07,1.7791986465454061e-09,2.2547087428392842e-07,2.4366877478314566e-07,2.255729501484893e-07,2.3616364582267123e-07,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,visits/bounded-expectation/k-10,9.82919882517308e-05,1.541979145258665e-06,9.749999298946932e-05,0.00010417725570732728,9.754151687957346e-05,0.00010152050526812673,30 +pydtmc,reducible-n0100-s31415,reducible,100,31415,visits/bounded-expectation/k-100,0.00022777098638471216,2.792003215290606e-06,0.0002257605010527186,0.00025768749037524685,0.00022627098951488733,0.0002408125001238659,30 +pydtmc,reducible-n0250-s01729,reducible,250,1729,construction/public-consumed,0.07150902099965606,0.0006497499998658895,0.07107076049578609,0.07348530198942171,0.07117695800843649,0.07201391649141442,30 +pydtmc,reducible-n0250-s01729,reducible,250,1729,evolution/k-10,0.0003780624974751845,6.875023245811462e-06,0.0003711874960572459,0.00038421876524807885,0.000372270485968329,0.00037985452363500374,30 +pydtmc,reducible-n0250-s01729,reducible,250,1729,evolution/k-100,0.001296520495088771,8.417002391070127e-06,0.001288416751776822,0.0013069269843981601,0.0012914789986098185,0.0013039790064794943,30 +pydtmc,reducible-n0250-s01729,reducible,250,1729,evolution/one-step,0.00028645849670283496,3.229011781513691e-06,0.00028411500534275547,0.00028971875144634396,0.0002851879980880767,0.0002887914888560772,30 +pydtmc,reducible-n0250-s01729,reducible,250,1729,hitting-probability/cold-all-states,0.007577562995720655,3.0186492949724197e-05,0.007548062756541185,0.007607166240632068,0.007554291994892992,0.007604854006785899,30 +pydtmc,reducible-n0250-s01729,reducible,250,1729,hitting-time/cold-all-states,0.00784670801658649,2.2458014427684247e-05,0.007825489505194128,0.00788096876203781,0.007835262177104596,0.007860125013394281,30 +pydtmc,reducible-n0250-s01729,reducible,250,1729,occupation-matrix,0.711441166989971,0.0025254580104956403,0.7071160207560752,0.7131466769933468,0.7099074790021405,0.7125578334962483,30 +pydtmc,reducible-n0250-s01729,reducible,250,1729,power/10,0.022551708505488932,7.781251042615622e-05,0.022473322991572786,0.02262197849631775,0.022493937503895722,0.02259343750483822,30 +pydtmc,reducible-n0250-s01729,reducible,250,1729,power/100,0.025373125507030636,0.0001773330004652962,0.02514743748906767,0.02551442676485749,0.02522420849709306,0.025482020500930957,30 +pydtmc,reducible-n0250-s01729,reducible,250,1729,power/2,0.020855333015788347,0.00018856200040318072,0.02067970826465171,0.0210645312545239,0.020722416491480544,0.02100143750431016,30 +pydtmc,reducible-n0250-s01729,reducible,250,1729,stationary,0.016282750002574176,0.00022422948677558452,0.01611186452646507,0.01650894823978888,0.016167833004146814,0.01647864599362947,30 +pydtmc,reducible-n0250-s01729,reducible,250,1729,structure/classes-cold,0.007047999504720792,1.4563003787770867e-05,0.007036520742985886,0.007068687002174556,0.007040500000584871,0.007061583499307744,30 +pydtmc,reducible-n0250-s01729,reducible,250,1729,structure/classes-lifecycle,0.07748327100125607,0.0003682704991661012,0.07710465624404605,0.07780572849151213,0.07725164550356567,0.07776124999509193,30 +pydtmc,reducible-n0250-s01729,reducible,250,1729,structure/classes-warm/access,2.196270492277108e-07,1.0813004337251111e-09,2.183937504014466e-07,2.2051672422094271e-07,2.1868329931749032e-07,2.202833493356593e-07,30 +pydtmc,reducible-n0250-s01729,reducible,250,1729,structure/classes-warm/consumed,1.3600210400181824e-05,2.476460067555248e-08,1.357054059917573e-05,1.3623056251526577e-05,1.3584310398437084e-05,1.3620464599807748e-05,30 +pydtmc,reducible-n0250-s01729,reducible,250,1729,structure/irreducible-cold,0.006918062514159828,2.556199615355581e-05,0.006898739258758724,0.007007843996689189,0.006902395500219427,0.00699208350815752,30 +pydtmc,reducible-n0250-s01729,reducible,250,1729,structure/irreducible-warm,2.2083334915805608e-07,8.791990694589894e-10,2.2005109858582728e-07,2.236802232800983e-07,2.201834024162963e-07,2.2262919956119732e-07,30 +pydtmc,reducible-n0250-s02718,reducible,250,2718,construction/public-consumed,0.06981777049077209,0.0005576664989348501,0.06948506226035533,0.07197522924252553,0.0695713125023758,0.0716439374955371,30 +pydtmc,reducible-n0250-s02718,reducible,250,2718,evolution/k-10,0.0003821874997811392,8.333503501489758e-06,0.00037430199154186994,0.0003917184949386865,0.0003765419824048877,0.0003879374999087304,30 +pydtmc,reducible-n0250-s02718,reducible,250,2718,evolution/k-100,0.001299499999731779,1.1103998986072838e-05,0.0012886042532045394,0.0013101454969728366,0.0012912290112581104,0.0013046250096522272,30 +pydtmc,reducible-n0250-s02718,reducible,250,2718,evolution/one-step,0.00028806198679376394,5.436988431029022e-06,0.0002824580005835742,0.00029310401441762224,0.0002832080062944442,0.0002923749852925539,30 +pydtmc,reducible-n0250-s02718,reducible,250,2718,hitting-probability/cold-all-states,0.0075475004996405914,3.656299668364227e-05,0.0075167184841120616,0.007613927002239507,0.007524936998379417,0.007580103992950171,30 +pydtmc,reducible-n0250-s02718,reducible,250,2718,hitting-time/cold-all-states,0.007791520489263348,2.2353982785716653e-05,0.007771552249323577,0.007823552004992962,0.007775708014378324,0.007811699147350737,30 +pydtmc,reducible-n0250-s02718,reducible,250,2718,occupation-matrix,0.7049541875021532,0.0033611455146456137,0.7024889995154808,0.7083564900094643,0.7038679590041284,0.7077493749966379,30 +pydtmc,reducible-n0250-s02718,reducible,250,2718,power/10,0.022493895507068373,7.46040022931993e-05,0.022439437263528816,0.022609395746258087,0.022466125519713387,0.022566750005353242,30 +pydtmc,reducible-n0250-s02718,reducible,250,2718,power/100,0.02535964600974694,6.810399645473808e-05,0.025298958746134304,0.02545003123668721,0.02530543750617653,0.025413020499399863,30 +pydtmc,reducible-n0250-s02718,reducible,250,2718,power/2,0.02085012501629535,0.0001417915045749396,0.020662041744799353,0.02095446875318885,0.02075312499073334,0.02091841649962589,30 +pydtmc,reducible-n0250-s02718,reducible,250,2718,stationary,0.016199500008951873,7.12289911461994e-05,0.015909999747236725,0.01624351001373725,0.016151624993653968,0.016230240300501464,30 +pydtmc,reducible-n0250-s02718,reducible,250,2718,structure/classes-cold,0.006996166513999924,4.979199729859829e-05,0.006920739491761196,0.007038521238428075,0.006942603999050334,0.00703583299764432,30 +pydtmc,reducible-n0250-s02718,reducible,250,2718,structure/classes-lifecycle,0.07800229149870574,0.0002685624931473285,0.07769657350581838,0.07823626101890113,0.07783929098513909,0.07815745849802624,30 +pydtmc,reducible-n0250-s02718,reducible,250,2718,structure/classes-warm/access,2.1682079968741164e-07,4.686997272074272e-10,2.1637497557094319e-07,2.1818542445544154e-07,2.1646039967890827e-07,2.177002644748427e-07,30 +pydtmc,reducible-n0250-s02718,reducible,250,2718,structure/classes-warm/consumed,1.35786229497171e-05,5.981350841466172e-09,1.3572826074232581e-05,1.3587854149955091e-05,1.3574818750203122e-05,1.3583889549772722e-05,30 +pydtmc,reducible-n0250-s02718,reducible,250,2718,structure/irreducible-cold,0.0069365625095088035,7.44794961065054e-05,0.006836239495896734,0.006999614248343278,0.006891604512929916,0.0069922371294524055,30 +pydtmc,reducible-n0250-s02718,reducible,250,2718,structure/irreducible-warm,2.2075000015320255e-07,1.2061995221301652e-09,2.199926988396328e-07,2.2237087687244637e-07,2.203166499384679e-07,2.2163145978993271e-07,30 +pydtmc,reducible-n0250-s31415,reducible,250,31415,construction/public-consumed,0.0694443544925889,0.0005962499999441206,0.06887473975803005,0.07004103125655092,0.06899387450539507,0.06997508349013515,30 +pydtmc,reducible-n0250-s31415,reducible,250,31415,evolution/k-10,0.0003906875062966719,1.3167009456083179e-05,0.00038245797622948885,0.0004200315015623346,0.0003853124944726005,0.00040716701187193394,30 +pydtmc,reducible-n0250-s31415,reducible,250,31415,evolution/k-100,0.0013001455081393942,1.1958007235080004e-05,0.0012927604839205742,0.001319458257057704,0.0012950210075359792,0.001316041496465914,30 +pydtmc,reducible-n0250-s31415,reducible,250,31415,evolution/one-step,0.0002980210119858384,6.292015314102173e-06,0.00029201000870671123,0.00030947901541367173,0.00029287501820363104,0.0003034999972442165,30 +pydtmc,reducible-n0250-s31415,reducible,250,31415,hitting-probability/cold-all-states,0.007549020505393855,2.2104490199126303e-05,0.007534312739153393,0.007579479242849629,0.007544228516053408,0.007568603992694989,30 +pydtmc,reducible-n0250-s31415,reducible,250,31415,hitting-time/cold-all-states,0.00784985399513971,1.5791505575180054e-05,0.007835479242203292,0.007865406252676621,0.007842624996555969,0.007859812991227955,30 +pydtmc,reducible-n0250-s31415,reducible,250,31415,occupation-matrix,0.7056145834940253,0.0012371460034046322,0.7046071662625764,0.707104583758337,0.7048554789944319,0.7068517294974299,30 +pydtmc,reducible-n0250-s31415,reducible,250,31415,power/10,0.0225538334925659,7.297850970644504e-05,0.022460333253548015,0.022607469240028877,0.022491791998618282,0.022589458501897752,30 +pydtmc,reducible-n0250-s31415,reducible,250,31415,power/100,0.025809729006141424,0.00025295848899986595,0.02535257275303593,0.02602254201337928,0.02556860400363803,0.025938041508197784,30 +pydtmc,reducible-n0250-s31415,reducible,250,31415,power/2,0.0209492499998305,7.968751015141606e-05,0.02087616674543824,0.021052676493127365,0.020889854000415653,0.021003791509428993,30 +pydtmc,reducible-n0250-s31415,reducible,250,31415,stationary,0.016123437992064282,6.656200275756419e-05,0.016045677752117626,0.01618712475465145,0.016100959008326754,0.016172437492059544,30 +pydtmc,reducible-n0250-s31415,reducible,250,31415,structure/classes-cold,0.007062229007715359,4.9208989366889e-05,0.0069723752603749745,0.007103343486960512,0.007005250008660369,0.007096978995832615,30 +pydtmc,reducible-n0250-s31415,reducible,250,31415,structure/classes-lifecycle,0.07828472949040588,0.00050206201558467,0.07772490649949759,0.07867143749899697,0.07779452048998792,0.07860727098886855,30 +pydtmc,reducible-n0250-s31415,reducible,250,31415,structure/classes-warm/access,2.1745834965258836e-07,8.895498467609258e-10,2.1700312427128668e-07,2.3640420040464962e-07,2.1711035078624263e-07,2.2674892428767632e-07,30 +pydtmc,reducible-n0250-s31415,reducible,250,31415,structure/classes-warm/consumed,1.3630900000862312e-05,4.266650648787475e-09,1.3625973976013484e-05,1.3634611451561795e-05,1.3628241699188948e-05,1.3633393749478274e-05,30 +pydtmc,reducible-n0250-s31415,reducible,250,31415,structure/irreducible-cold,0.006935916491784155,2.729150583036244e-05,0.006915698497323319,0.006972239505557809,0.006922095152913243,0.006957213046916876,30 +pydtmc,reducible-n0250-s31415,reducible,250,31415,structure/irreducible-warm,2.2470409894594923e-07,1.2457981938496229e-09,2.237375003460329e-07,2.3464059777325017e-07,2.2411460086004808e-07,2.300291511346586e-07,30 +pydtmc,reducible-n0500-s01729,reducible,500,1729,construction/public-consumed,0.28834841650677845,0.004000041488325223,0.28399904175603297,0.2917764997546328,0.2866074584890157,0.29094256249663886,30 +pydtmc,reducible-n0500-s01729,reducible,500,1729,evolution/k-10,0.0010267704928992316,9.624491212889552e-06,0.0010177707590628415,0.0010413332493044436,0.001019603994791396,0.0010300829890184104,30 +pydtmc,reducible-n0500-s01729,reducible,500,1729,evolution/k-100,0.004123187507502735,1.1229509254917502e-05,0.004114478986593895,0.004138791737204883,0.004118603988899849,0.004130922234253376,30 +pydtmc,reducible-n0500-s01729,reducible,500,1729,evolution/one-step,0.0007197085069492459,1.0979012586176395e-05,0.0007130832600523718,0.0007367190191871487,0.0007165839779190719,0.000731479492969811,30 +pydtmc,reducible-n0500-s01729,reducible,500,1729,hitting-probability/cold-all-states,0.05364387499867007,0.00010237550304736942,0.05360438549541868,0.05381731200031936,0.053623792016878724,0.05379179201554507,30 +pydtmc,reducible-n0500-s01729,reducible,500,1729,hitting-time/cold-all-states,0.05446908298472408,0.00011500049731694162,0.05437127025652444,0.054696823259291705,0.05441291650640778,0.054649270488880575,30 +pydtmc,reducible-n0500-s01729,reducible,500,1729,power/10,0.09004727099090815,0.0005896664952160791,0.08904483351216186,0.09028293724986725,0.08921299950452521,0.09019675049057696,30 +pydtmc,reducible-n0500-s01729,reducible,500,1729,power/100,0.10689564551285002,0.0007283750019269064,0.1060581037600059,0.10747443700529402,0.10655825000139885,0.10734250000678003,30 +pydtmc,reducible-n0500-s01729,reducible,500,1729,power/2,0.08384662499884143,0.0003074584965361282,0.08363683326024329,0.08426783326285658,0.08366974999080412,0.08417733298847452,30 +pydtmc,reducible-n0500-s01729,reducible,500,1729,stationary,0.06301679150783457,0.00025527100660838187,0.06274613575078547,0.06318600049417,0.06279733299743384,0.06314631248824298,30 +pydtmc,reducible-n0500-s01729,reducible,500,1729,structure/classes-cold,0.02743108299910091,5.262449849396944e-05,0.0273827190103475,0.027482916004373692,0.02740112135070376,0.02745210350258276,30 +pydtmc,reducible-n0500-s01729,reducible,500,1729,structure/classes-lifecycle,0.31867191700439434,0.0026295409916201606,0.3155437504974543,0.3205142709921347,0.3163322290056385,0.3197748321148538,30 +pydtmc,reducible-n0500-s01729,reducible,500,1729,structure/classes-warm/access,2.144999511074275e-07,1.1749521945603381e-09,2.1363440173445268e-07,2.3408650158671663e-07,2.137743758794386e-07,2.2411595582525477e-07,30 +pydtmc,reducible-n0500-s01729,reducible,500,1729,structure/classes-warm/consumed,2.8773789601109456e-05,2.0266648789401433e-08,2.8760130174487132e-05,2.8796759374381508e-05,2.8763743750459978e-05,2.879102289734874e-05,30 +pydtmc,reducible-n0500-s01729,reducible,500,1729,structure/irreducible-cold,0.027529937491635792,0.00015733297914266586,0.027380041508877184,0.027738666751247365,0.027401583007303998,0.027693936994182877,30 +pydtmc,reducible-n0500-s01729,reducible,500,1729,structure/irreducible-warm,2.2156459890538826e-07,2.0166975446045287e-09,2.2015107679180802e-07,2.2598857613047584e-07,2.208312666698475e-07,2.238791494164616e-07,30 +pydtmc,reducible-n0500-s02718,reducible,500,2718,construction/public-consumed,0.28697708349500317,0.002797520995954983,0.28563739551464096,0.28986363600415643,0.285780166494078,0.28951672950643115,30 +pydtmc,reducible-n0500-s02718,reducible,500,2718,evolution/k-10,0.0010253749933326617,1.4687480870634317e-05,0.0010177814838243648,0.0010541984956944361,0.0010201039985986426,0.0010472294961800799,30 +pydtmc,reducible-n0500-s02718,reducible,500,2718,evolution/k-100,0.0041272505186498165,1.9333005184307694e-05,0.004112937247555237,0.004148489511862863,0.004118349987402326,0.004146478997427039,30 +pydtmc,reducible-n0500-s02718,reducible,500,2718,evolution/one-step,0.0007177294901339337,1.1396492482163012e-05,0.0007088542552082799,0.0007381354953395203,0.0007121874950826168,0.0007288339984370396,30 +pydtmc,reducible-n0500-s02718,reducible,500,2718,hitting-probability/cold-all-states,0.05391975000384264,0.0003172709984937683,0.053644072759198025,0.05432661448867293,0.05380566649546381,0.05409572950156871,30 +pydtmc,reducible-n0500-s02718,reducible,500,2718,hitting-time/cold-all-states,0.05449495848733932,0.00017537499661557376,0.05440251048275968,0.054735854238970205,0.05443947949970607,0.054711292003048584,30 +pydtmc,reducible-n0500-s02718,reducible,500,2718,power/10,0.09006822950323112,0.0005977295077173039,0.08941402124764863,0.09056195875018602,0.08949941699393094,0.09045272899675183,30 +pydtmc,reducible-n0500-s02718,reducible,500,2718,power/100,0.10585635449388064,0.0002242914924863726,0.10565516724454938,0.10612457275419729,0.10572243749629706,0.10601733349903952,30 +pydtmc,reducible-n0500-s02718,reducible,500,2718,power/2,0.0839403545105597,0.0006013539823470637,0.08339091700327117,0.08475311474467162,0.08348558351281099,0.08454670800711028,30 +pydtmc,reducible-n0500-s02718,reducible,500,2718,stationary,0.06303435399604496,0.0003356039960635826,0.06283852098567877,0.06353487524029333,0.06288714599213563,0.06349887500982732,30 +pydtmc,reducible-n0500-s02718,reducible,500,2718,structure/classes-cold,0.027773750509368256,0.00037325051380321383,0.027290614998491947,0.02783952051686356,0.027377416990930215,0.027832270992803387,30 +pydtmc,reducible-n0500-s02718,reducible,500,2718,structure/classes-lifecycle,0.3198487500048941,0.0027431665075710043,0.31759996899199905,0.3228269897517748,0.31807100815130984,0.3217536875017686,30 +pydtmc,reducible-n0500-s02718,reducible,500,2718,structure/classes-warm/access,2.1671875147148969e-07,6.874979590065614e-10,2.16032299795188e-07,2.1739272488048302e-07,2.1622084896080196e-07,2.1716664923587813e-07,30 +pydtmc,reducible-n0500-s02718,reducible,500,2718,structure/classes-warm/consumed,2.8856479149544612e-05,1.507499982835811e-08,2.8842513476411116e-05,2.8872515624971127e-05,2.8845795847882983e-05,2.8863027050101665e-05,30 +pydtmc,reducible-n0500-s02718,reducible,500,2718,structure/irreducible-cold,0.027587562493863516,8.208300278056413e-05,0.027525479497853667,0.02776330222695833,0.027540896015125327,0.02775229151302483,30 +pydtmc,reducible-n0500-s02718,reducible,500,2718,structure/irreducible-warm,2.2203959961188958e-07,1.3396012946031869e-09,2.2136037587188183e-07,2.2355515029630624e-07,2.2164574576891028e-07,2.2337920090649277e-07,30 +pydtmc,reducible-n0500-s31415,reducible,500,31415,construction/public-consumed,0.28366649999225046,0.001526354521047324,0.28236994750477606,0.2852057817581226,0.28289377100009006,0.2846426460018847,30 +pydtmc,reducible-n0500-s31415,reducible,500,31415,evolution/k-10,0.001019937510136515,1.3521028449758887e-05,0.0010123639949597418,0.0010424064967082813,0.0010170415043830872,0.0010357290011597797,30 +pydtmc,reducible-n0500-s31415,reducible,500,31415,evolution/k-100,0.00412456298363395,1.5791505575180054e-05,0.004115322517463937,0.00416422924172366,0.004116935414276668,0.004145750004681759,30 +pydtmc,reducible-n0500-s31415,reducible,500,31415,evolution/one-step,0.000710687498212792,9.187511750496924e-06,0.0007036669994704425,0.0007300105062313378,0.000704874997609295,0.0007241039857035503,30 +pydtmc,reducible-n0500-s31415,reducible,500,31415,hitting-probability/cold-all-states,0.05375164549332112,9.716649947222322e-05,0.05367238549661124,0.05386962500051595,0.053698197392441215,0.053833208483411,30 +pydtmc,reducible-n0500-s31415,reducible,500,31415,hitting-time/cold-all-states,0.05472635450132657,0.00010495800233911723,0.05462119823641842,0.05481690598389832,0.054679270993801765,0.05476581248512957,30 +pydtmc,reducible-n0500-s31415,reducible,500,31415,power/10,0.08929039600479882,0.00038506300188601017,0.08905689549283125,0.09004494825785514,0.08909310451417696,0.08994452099432237,30 +pydtmc,reducible-n0500-s31415,reducible,500,31415,power/100,0.10629908401460852,0.0007481664943043143,0.10592941675713519,0.10830080201412784,0.1060165629896801,0.107878228998743,30 +pydtmc,reducible-n0500-s31415,reducible,500,31415,power/2,0.08363847850705497,0.00032718702277634293,0.08345661400380777,0.08418420849920949,0.08354108265411923,0.08401191649318207,30 +pydtmc,reducible-n0500-s31415,reducible,500,31415,stationary,0.06348349999461789,0.0003116665029665455,0.06261169799836352,0.06375375023344532,0.06328800049959682,0.0636515420046635,30 +pydtmc,reducible-n0500-s31415,reducible,500,31415,structure/classes-cold,0.027978166501270607,0.00014322949573397636,0.02774716650310438,0.02811377100442769,0.027860374975716695,0.028076124988729134,30 +pydtmc,reducible-n0500-s31415,reducible,500,31415,structure/classes-lifecycle,0.317935770508484,0.002429625004879199,0.31627461424068315,0.32114103123603854,0.3165654374897713,0.32067725001252256,30 +pydtmc,reducible-n0500-s31415,reducible,500,31415,structure/classes-warm/access,2.158520495868288e-07,6.333008059300443e-10,2.1538125147344544e-07,2.1657910183421336e-07,2.1556008759944234e-07,2.1648749971063807e-07,30 +pydtmc,reducible-n0500-s31415,reducible,500,31415,structure/classes-warm/consumed,2.886559164908249e-05,1.0637499508448601e-08,2.8853322923532688e-05,2.88726031256374e-05,2.885715420125052e-05,2.8867991651350167e-05,30 +pydtmc,reducible-n0500-s31415,reducible,500,31415,structure/irreducible-cold,0.02783247899787966,0.00011745799565687776,0.027675031240505632,0.02790752123837592,0.02771568749449216,0.0279010000085691,30 +pydtmc,reducible-n0500-s31415,reducible,500,31415,structure/irreducible-warm,2.2225624998100103e-07,6.813002983108105e-10,2.2132922458695246e-07,2.2274582515819929e-07,2.215895496192388e-07,2.2253330098465084e-07,30 +pydtmc,reducible-n1000-s01729,reducible,1000,1729,construction/public-consumed,1.1563063329958823,0.010075395504827611,1.146133593741979,1.1632721460046014,1.1479922504950082,1.16026172900456,30 +pydtmc,reducible-n1000-s01729,reducible,1000,1729,evolution/k-10,0.0036080214922549203,5.729201075155288e-05,0.0035499372461345047,0.0036584377667168155,0.003569270993466489,0.0036337500059744343,30 +pydtmc,reducible-n1000-s01729,reducible,1000,1729,evolution/k-100,0.020783479005331174,0.00016722900909371674,0.020636458742956165,0.02095410400943365,0.020701036246828154,0.020924187498167157,30 +pydtmc,reducible-n1000-s01729,reducible,1000,1729,evolution/one-step,0.0019616249919636175,4.847899253945798e-05,0.001909301987325307,0.0019876662336173467,0.0019130712025798857,0.0019799165020231158,30 +pydtmc,reducible-n1000-s01729,reducible,1000,1729,structure/classes-cold,0.11027758350246586,0.00039083352021407336,0.10983430175110698,0.11048208298598183,0.10988424997776747,0.1103890840022359,30 +pydtmc,reducible-n1000-s01729,reducible,1000,1729,structure/classes-lifecycle,1.3044449999870267,0.009985770986531861,1.2955986247543478,1.3147337604968925,1.298863458490814,1.310569604000193,30 +pydtmc,reducible-n1000-s01729,reducible,1000,1729,structure/classes-warm/access,2.1682919905288145e-07,5.083013093098967e-10,2.162864497222472e-07,2.1729477666667663e-07,2.164374993299134e-07,2.1697910124203188e-07,30 +pydtmc,reducible-n1000-s01729,reducible,1000,1729,structure/classes-warm/consumed,5.853695625119144e-05,1.5409580082632632e-07,5.8450760449341034e-05,5.9322197899018643e-05,5.8459979148756247e-05,5.931041941261356e-05,30 +pydtmc,reducible-n1000-s01729,reducible,1000,1729,structure/irreducible-cold,0.11027839599410072,0.0007611254986841232,0.10904908325755969,0.1108459895112901,0.10986252050497569,0.11066137500165496,30 +pydtmc,reducible-n1000-s01729,reducible,1000,1729,structure/irreducible-warm,2.21062550554052e-07,6.104499334469485e-10,2.206646000558976e-07,2.2441877517849207e-07,2.2069375118007883e-07,2.229833509773016e-07,30 +pydtmc,reducible-n1000-s02718,reducible,1000,2718,construction/public-consumed,1.182518624496879,0.020812208487768658,1.1533875937602716,1.1956922917379416,1.1622773544950178,1.1859153955156216,30 +pydtmc,reducible-n1000-s02718,reducible,1000,2718,evolution/k-10,0.003646583514637314,7.29375024093315e-05,0.0035760939863394015,0.0037178334896452725,0.0035856875038007274,0.003684479001094587,30 +pydtmc,reducible-n1000-s02718,reducible,1000,2718,evolution/k-100,0.02068781251728069,0.0001878125185612589,0.02052861449919874,0.020888250255666208,0.020579646006808616,0.02083304148982279,30 +pydtmc,reducible-n1000-s02718,reducible,1000,2718,evolution/one-step,0.0019041875057155266,5.9354002587497234e-05,0.0018343542396905832,0.0019493537474772893,0.0018527295032981783,0.0019335629913257435,30 +pydtmc,reducible-n1000-s02718,reducible,1000,2718,structure/classes-cold,0.10949737500050105,0.000585479021538049,0.10892769773636246,0.11014820900891209,0.1089982085104566,0.11003974999766797,30 +pydtmc,reducible-n1000-s02718,reducible,1000,2718,structure/classes-lifecycle,1.304182874999242,0.008590937010012567,1.2943093959984253,1.3120522392637213,1.2981167920079315,1.3091892499942333,30 +pydtmc,reducible-n1000-s02718,reducible,1000,2718,structure/classes-warm/access,2.1716670016758144e-07,1.0249510523863195e-09,2.166052261600271e-07,2.302708766364958e-07,2.168854000046849e-07,2.25314601266291e-07,30 +pydtmc,reducible-n1000-s02718,reducible,1000,2718,structure/classes-warm/consumed,5.9319079200213315e-05,8.255021501099723e-07,5.8462672875612044e-05,5.97967812747811e-05,5.88929603502038e-05,5.93654708514805e-05,30 +pydtmc,reducible-n1000-s02718,reducible,1000,2718,structure/irreducible-cold,0.1096607499930542,0.0003998750034952536,0.1090684377704747,0.1099675829973421,0.10927045800781343,0.10984041600022465,30 +pydtmc,reducible-n1000-s02718,reducible,1000,2718,structure/irreducible-warm,2.236708503914997e-07,8.35399259813141e-10,2.2319582421914673e-07,2.2526557513629085e-07,2.2326044872897912e-07,2.2450630214734702e-07,30 +pydtmc,reducible-n1000-s31415,reducible,1000,31415,construction/public-consumed,1.1749504170147702,0.014375395505339839,1.1593390212510712,1.1806635102329892,1.160753968406789,1.1792226669931551,30 +pydtmc,reducible-n1000-s31415,reducible,1000,31415,evolution/k-10,0.0035799795150524005,7.537448254879564e-05,0.0035267604907858185,0.0036629272435675375,0.003536499512847513,0.0036427500017452985,30 +pydtmc,reducible-n1000-s31415,reducible,1000,31415,evolution/k-100,0.020594270506990142,0.0003553125134203583,0.020278374751796946,0.02106159374670824,0.020440520995180123,0.020856730727973623,30 +pydtmc,reducible-n1000-s31415,reducible,1000,31415,evolution/one-step,0.0019718749972525984,6.560397741850466e-05,0.0018843337529688142,0.0020056150024174713,0.0019115625036647543,0.0019947705004597083,30 +pydtmc,reducible-n1000-s31415,reducible,1000,31415,structure/classes-cold,0.10991483349062037,0.0005667499935952947,0.1095171772321919,0.11083219775900943,0.10965739599487279,0.11070433299755678,30 +pydtmc,reducible-n1000-s31415,reducible,1000,31415,structure/classes-lifecycle,1.2910136245045578,0.005049437007983215,1.2871528332470916,1.2997019582398934,1.288514749991009,1.2943170215003192,30 +pydtmc,reducible-n1000-s31415,reducible,1000,31415,structure/classes-warm/access,2.186521000112407e-07,2.9166491003707006e-09,2.1633539945469237e-07,2.2531042413902468e-07,2.1710966881073544e-07,2.2336669935612008e-07,30 +pydtmc,reducible-n1000-s31415,reducible,1000,31415,structure/classes-warm/consumed,5.9253889550745954e-05,6.135005096439256e-08,5.851188539818395e-05,5.9295080224546835e-05,5.890924999839627e-05,5.9278154200001154e-05,30 +pydtmc,reducible-n1000-s31415,reducible,1000,31415,structure/irreducible-cold,0.10897737499908544,0.0002112709917128086,0.10879462499724468,0.1101548329970683,0.10883058350009378,0.1096025619917782,30 +pydtmc,reducible-n1000-s31415,reducible,1000,31415,structure/irreducible-warm,2.2267499880399554e-07,8.520481060258954e-10,2.2175105041242204e-07,2.2318965129670689e-07,2.2202499967534096e-07,2.2306250029942022e-07,30 diff --git a/benchmark/results/verification.json b/benchmark/results/verification.json new file mode 100644 --- /dev/null +++ b/benchmark/results/verification.json @@ -0,0 +1,9799 @@ +{ + "schema_version": 1, + "absolute_tolerance": 1e-10, + "relative_tolerance": 1e-08, + "comparisons": [ + { + "dataset": "absorbing-n0010-s01729", + "operation": "evolve_1", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 2.0167455673302878e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s01729", + "operation": "evolve_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 5.310216908385393e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s01729", + "operation": "power_10", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 7.338201400639298e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s01729", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0010-s01729", + "operation": "finite_time_n_step_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0010-s01729", + "operation": "finite_time_n_step_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0010-s01729", + "operation": "finite_time_observation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0010-s01729", + "operation": "finite_time_observation_100", + "max_absolute_error": 1.6653345369377348e-16, + "max_relative_error": 3.3874595772765285e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s01729", + "operation": "hitting_probability", + "max_absolute_error": 1.2212453270876722e-15, + "max_relative_error": 1.221245327087672e-15, + "passed": true + }, + { + "dataset": "absorbing-n0010-s01729", + "operation": "hitting_time", + "max_absolute_error": 3.552713678800501e-15, + "max_relative_error": 6.617201002936084e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s01729", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 4.745503742282739e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s01729", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 2.0679515313825692e-25, + "max_relative_error": 3.4989808127112816e-15, + "passed": true + }, + { + "dataset": "absorbing-n0010-s01729", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 2.51576843765402e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s01729", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.110223024888545e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s01729", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 4.163336342344337e-17, + "max_relative_error": 3.546629235264686e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s01729", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 5.5242492274082495e-17, + "max_relative_error": 2.3285553079288737e-07, + "passed": true + }, + { + "dataset": "absorbing-n0010-s01729", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0010-s01729", + "operation": "return_bounded_100", + "max_absolute_error": 8.326672684688674e-17, + "max_relative_error": 3.4654647656453883e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s01729", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0010-s01729", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0010-s01729", + "operation": "stationary[8]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0010-s01729", + "operation": "stationary[9]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0010-s01729", + "operation": "fundamental", + "max_absolute_error": 6.661338147750939e-16, + "max_relative_error": 8.694913810446279e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s01729", + "operation": "absorption_probability", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 6.440161352389289e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s01729", + "operation": "absorption_time", + "max_absolute_error": 1.7763568394002505e-15, + "max_relative_error": 3.802392865564685e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s01729", + "operation": "occupation", + "max_absolute_error": 2.7755575615628914e-16, + "max_relative_error": 6.356785445239038e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s02718", + "operation": "evolve_1", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 1.1599291041634164e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s02718", + "operation": "evolve_10", + "max_absolute_error": 1.6653345369377348e-16, + "max_relative_error": 4.3488985974927346e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s02718", + "operation": "power_10", + "max_absolute_error": 1.6653345369377348e-16, + "max_relative_error": 6.746414730946615e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s02718", + "operation": "finite_time_step", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 1.3980164930986856e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s02718", + "operation": "finite_time_n_step_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0010-s02718", + "operation": "finite_time_n_step_100", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 2.0939007586447778e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s02718", + "operation": "finite_time_observation_10", + "max_absolute_error": 1.6653345369377348e-16, + "max_relative_error": 3.4109526436656557e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s02718", + "operation": "finite_time_observation_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0010-s02718", + "operation": "hitting_probability", + "max_absolute_error": 6.661338147750939e-16, + "max_relative_error": 6.661338147750939e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s02718", + "operation": "hitting_time", + "max_absolute_error": 2.6645352591003757e-15, + "max_relative_error": 3.923212990174697e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s02718", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 4.0957270261660086e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s02718", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 2.150669592637872e-23, + "max_relative_error": 1.5271452937181093e-15, + "passed": true + }, + { + "dataset": "absorbing-n0010-s02718", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 2.744889111977317e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s02718", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 2.2204462255768413e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s02718", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 2.9054050942289243e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s02718", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 5.232043105851008e-18, + "max_relative_error": 6.588611737330576e-11, + "passed": true + }, + { + "dataset": "absorbing-n0010-s02718", + "operation": "return_bounded_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.908709022849107e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s02718", + "operation": "return_bounded_100", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.7485297555104035e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s02718", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 1.9084728056876882e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s02718", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 1.4210854715202004e-14, + "max_relative_error": 2.881564125299743e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s02718", + "operation": "stationary[8]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0010-s02718", + "operation": "stationary[9]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0010-s02718", + "operation": "fundamental", + "max_absolute_error": 6.661338147750939e-16, + "max_relative_error": 8.934492738544794e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s02718", + "operation": "absorption_probability", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 6.385398623111115e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s02718", + "operation": "absorption_time", + "max_absolute_error": 4.440892098500626e-15, + "max_relative_error": 6.000097732215389e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s02718", + "operation": "occupation", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 6.59384856452051e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s31415", + "operation": "evolve_1", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 1.8979029457706122e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s31415", + "operation": "evolve_10", + "max_absolute_error": 1.6653345369377348e-16, + "max_relative_error": 4.845732900860065e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s31415", + "operation": "power_10", + "max_absolute_error": 1.6653345369377348e-16, + "max_relative_error": 5.47716856653078e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s31415", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0010-s31415", + "operation": "finite_time_n_step_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.333619577893121e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s31415", + "operation": "finite_time_n_step_100", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 2.3038345173901175e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s31415", + "operation": "finite_time_observation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0010-s31415", + "operation": "finite_time_observation_100", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 4.1215084844529547e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s31415", + "operation": "hitting_probability", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 4.440892098500625e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s31415", + "operation": "hitting_time", + "max_absolute_error": 5.329070518200751e-15, + "max_relative_error": 9.508027831949832e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s31415", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 4.346629176793313e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s31415", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 1.6543612251060553e-24, + "max_relative_error": 2.6574336378524595e-15, + "passed": true + }, + { + "dataset": "absorbing-n0010-s31415", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.300667924856139e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s31415", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 5.551115123125783e-16, + "max_relative_error": 5.551115138974106e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s31415", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 1.6653345369377348e-16, + "max_relative_error": 1.1373616272858723e-15, + "passed": true + }, + { + "dataset": "absorbing-n0010-s31415", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 1.3846135328084809e-17, + "max_relative_error": 4.84981747123021e-09, + "passed": true + }, + { + "dataset": "absorbing-n0010-s31415", + "operation": "return_bounded_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.7089037893608734e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s31415", + "operation": "return_bounded_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0010-s31415", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 1.7480569988634517e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s31415", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 7.105427357601002e-15, + "max_relative_error": 1.560092553550655e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s31415", + "operation": "stationary[8]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0010-s31415", + "operation": "stationary[9]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0010-s31415", + "operation": "fundamental", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 5.191984172215779e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s31415", + "operation": "absorption_probability", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 4.186877529987585e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s31415", + "operation": "absorption_time", + "max_absolute_error": 2.6645352591003757e-15, + "max_relative_error": 4.754013915974916e-16, + "passed": true + }, + { + "dataset": "absorbing-n0010-s31415", + "operation": "occupation", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 5.848275208118312e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s01729", + "operation": "evolve_1", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 2.2080327761162085e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s01729", + "operation": "evolve_10", + "max_absolute_error": 1.6653345369377348e-16, + "max_relative_error": 6.772088019813413e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s01729", + "operation": "power_10", + "max_absolute_error": 1.6653345369377348e-16, + "max_relative_error": 1.2840946280972506e-15, + "passed": true + }, + { + "dataset": "absorbing-n0025-s01729", + "operation": "finite_time_step", + "max_absolute_error": 8.673617379884035e-19, + "max_relative_error": 2.436619282410499e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s01729", + "operation": "finite_time_n_step_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 4.416665128531416e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s01729", + "operation": "finite_time_n_step_100", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 9.344238145357615e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s01729", + "operation": "finite_time_observation_10", + "max_absolute_error": 1.6653345369377348e-16, + "max_relative_error": 6.272462289456792e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s01729", + "operation": "finite_time_observation_100", + "max_absolute_error": 7.771561172376096e-16, + "max_relative_error": 1.6784416324676167e-15, + "passed": true + }, + { + "dataset": "absorbing-n0025-s01729", + "operation": "hitting_probability", + "max_absolute_error": 1.4432899320127035e-15, + "max_relative_error": 1.443289932012703e-15, + "passed": true + }, + { + "dataset": "absorbing-n0025-s01729", + "operation": "hitting_time", + "max_absolute_error": 2.3092638912203256e-14, + "max_relative_error": 1.8844806928569663e-15, + "passed": true + }, + { + "dataset": "absorbing-n0025-s01729", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 3.469446951953614e-17, + "max_relative_error": 8.61617006356622e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s01729", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 1.3213713977167085e-19, + "max_relative_error": 5.852379035991313e-15, + "passed": true + }, + { + "dataset": "absorbing-n0025-s01729", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 4.144410316746671e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s01729", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 1.3322676295501878e-15, + "max_relative_error": 1.3326145143432022e-15, + "passed": true + }, + { + "dataset": "absorbing-n0025-s01729", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 7.174592327227143e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s01729", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 3.859759734048396e-17, + "max_relative_error": 1.4827896601484038e-13, + "passed": true + }, + { + "dataset": "absorbing-n0025-s01729", + "operation": "return_bounded_10", + "max_absolute_error": 8.326672684688674e-17, + "max_relative_error": 4.034902225660224e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s01729", + "operation": "return_bounded_100", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 1.1037290660310685e-15, + "passed": true + }, + { + "dataset": "absorbing-n0025-s01729", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 3.8505718607842507e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s01729", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 2.1316282072803006e-14, + "max_relative_error": 5.18234386977704e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s01729", + "operation": "stationary[23]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0025-s01729", + "operation": "stationary[24]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0025-s01729", + "operation": "fundamental", + "max_absolute_error": 1.3322676295501878e-15, + "max_relative_error": 2.181540980233736e-15, + "passed": true + }, + { + "dataset": "absorbing-n0025-s01729", + "operation": "absorption_probability", + "max_absolute_error": 8.881784197001252e-16, + "max_relative_error": 1.7742584044069541e-15, + "passed": true + }, + { + "dataset": "absorbing-n0025-s01729", + "operation": "absorption_time", + "max_absolute_error": 2.3092638912203256e-14, + "max_relative_error": 1.9040326672505644e-15, + "passed": true + }, + { + "dataset": "absorbing-n0025-s01729", + "operation": "occupation", + "max_absolute_error": 1.1102230246251565e-15, + "max_relative_error": 1.868500715009433e-15, + "passed": true + }, + { + "dataset": "absorbing-n0025-s02718", + "operation": "evolve_1", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 4.705194069070919e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s02718", + "operation": "evolve_10", + "max_absolute_error": 1.3877787807814457e-16, + "max_relative_error": 7.243677053862711e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s02718", + "operation": "power_10", + "max_absolute_error": 1.6653345369377348e-16, + "max_relative_error": 1.393077492839355e-15, + "passed": true + }, + { + "dataset": "absorbing-n0025-s02718", + "operation": "finite_time_step", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 2.1353263771606578e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s02718", + "operation": "finite_time_n_step_10", + "max_absolute_error": 1.6653345369377348e-16, + "max_relative_error": 6.177695666491163e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s02718", + "operation": "finite_time_n_step_100", + "max_absolute_error": 2.7755575615628914e-16, + "max_relative_error": 5.551404767724061e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s02718", + "operation": "finite_time_observation_10", + "max_absolute_error": 1.3877787807814457e-16, + "max_relative_error": 6.101217540280476e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s02718", + "operation": "finite_time_observation_100", + "max_absolute_error": 3.885780586188048e-16, + "max_relative_error": 8.771859054395511e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s02718", + "operation": "hitting_probability", + "max_absolute_error": 7.771561172376096e-16, + "max_relative_error": 7.771561172376093e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s02718", + "operation": "hitting_time", + "max_absolute_error": 1.5987211554602254e-14, + "max_relative_error": 1.0706457569568185e-15, + "passed": true + }, + { + "dataset": "absorbing-n0025-s02718", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 2.0816681711721685e-17, + "max_relative_error": 5.853599511969997e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s02718", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 3.3881317890172014e-19, + "max_relative_error": 5.34732408294892e-15, + "passed": true + }, + { + "dataset": "absorbing-n0025-s02718", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 4.337114073832784e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s02718", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 9.992007221626409e-16, + "max_relative_error": 1.000070318563441e-15, + "passed": true + }, + { + "dataset": "absorbing-n0025-s02718", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 9.099516502867358e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s02718", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 2.5804011705155006e-17, + "max_relative_error": 2.9675635941475365e-14, + "passed": true + }, + { + "dataset": "absorbing-n0025-s02718", + "operation": "return_bounded_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 4.3498875972603045e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s02718", + "operation": "return_bounded_100", + "max_absolute_error": 1.6653345369377348e-16, + "max_relative_error": 4.51392507767939e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s02718", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 2.9580676567682166e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s02718", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 1.4210854715202004e-14, + "max_relative_error": 3.293847317513224e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s02718", + "operation": "stationary[23]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0025-s02718", + "operation": "stationary[24]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0025-s02718", + "operation": "fundamental", + "max_absolute_error": 1.1102230246251565e-15, + "max_relative_error": 1.297691111585228e-15, + "passed": true + }, + { + "dataset": "absorbing-n0025-s02718", + "operation": "absorption_probability", + "max_absolute_error": 5.551115123125783e-16, + "max_relative_error": 1.1263130208266807e-15, + "passed": true + }, + { + "dataset": "absorbing-n0025-s02718", + "operation": "absorption_time", + "max_absolute_error": 1.2434497875801753e-14, + "max_relative_error": 8.554809001217975e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s02718", + "operation": "occupation", + "max_absolute_error": 6.661338147750939e-16, + "max_relative_error": 1.0885745708315316e-15, + "passed": true + }, + { + "dataset": "absorbing-n0025-s31415", + "operation": "evolve_1", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 2.6964637263055383e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s31415", + "operation": "evolve_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 5.808401708579956e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s31415", + "operation": "power_10", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 1.315887273852972e-15, + "passed": true + }, + { + "dataset": "absorbing-n0025-s31415", + "operation": "finite_time_step", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 2.8728476474183737e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s31415", + "operation": "finite_time_n_step_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 2.257342806010318e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s31415", + "operation": "finite_time_n_step_100", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 7.349361016733295e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s31415", + "operation": "finite_time_observation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0025-s31415", + "operation": "finite_time_observation_100", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 4.77939311063179e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s31415", + "operation": "hitting_probability", + "max_absolute_error": 1.5543122344752192e-15, + "max_relative_error": 1.5543122344752182e-15, + "passed": true + }, + { + "dataset": "absorbing-n0025-s31415", + "operation": "hitting_time", + "max_absolute_error": 1.4210854715202004e-14, + "max_relative_error": 1.2007320523878255e-15, + "passed": true + }, + { + "dataset": "absorbing-n0025-s31415", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 2.0816681711721685e-17, + "max_relative_error": 5.540666528871561e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s31415", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 1.1858461261560205e-19, + "max_relative_error": 4.922318096573706e-15, + "passed": true + }, + { + "dataset": "absorbing-n0025-s31415", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 3.9749237422187154e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s31415", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 4.442149347736487e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s31415", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 2.7755575615628914e-16, + "max_relative_error": 6.288270117977337e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s31415", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 2.0393842864452338e-16, + "max_relative_error": 7.205611520306534e-13, + "passed": true + }, + { + "dataset": "absorbing-n0025-s31415", + "operation": "return_bounded_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 2.1081455548036406e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s31415", + "operation": "return_bounded_100", + "max_absolute_error": 3.885780586188048e-16, + "max_relative_error": 1.0861074441664977e-15, + "passed": true + }, + { + "dataset": "absorbing-n0025-s31415", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 1.8318822987967916e-16, + "passed": true + }, + { + "dataset": "absorbing-n0025-s31415", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 4.973799150320701e-14, + "max_relative_error": 1.2633821887479663e-15, + "passed": true + }, + { + "dataset": "absorbing-n0025-s31415", + "operation": "stationary[23]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0025-s31415", + "operation": "stationary[24]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0025-s31415", + "operation": "fundamental", + "max_absolute_error": 1.3322676295501878e-15, + "max_relative_error": 2.184147064161872e-15, + "passed": true + }, + { + "dataset": "absorbing-n0025-s31415", + "operation": "absorption_probability", + "max_absolute_error": 8.881784197001252e-16, + "max_relative_error": 1.7011689538118021e-15, + "passed": true + }, + { + "dataset": "absorbing-n0025-s31415", + "operation": "absorption_time", + "max_absolute_error": 2.1316282072803006e-14, + "max_relative_error": 1.5739781583550526e-15, + "passed": true + }, + { + "dataset": "absorbing-n0025-s31415", + "operation": "occupation", + "max_absolute_error": 9.992007221626409e-16, + "max_relative_error": 1.839776617427561e-15, + "passed": true + }, + { + "dataset": "absorbing-n0050-s01729", + "operation": "evolve_1", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 5.821712000835274e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s01729", + "operation": "evolve_10", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 2.694176333908875e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s01729", + "operation": "power_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.3215378486980409e-15, + "passed": true + }, + { + "dataset": "absorbing-n0050-s01729", + "operation": "finite_time_step", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 1.7498672513560041e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s01729", + "operation": "finite_time_n_step_10", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 1.601701097432034e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s01729", + "operation": "finite_time_n_step_100", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 4.18195750668628e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s01729", + "operation": "finite_time_observation_10", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 1.3735152314055195e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s01729", + "operation": "finite_time_observation_100", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 2.0277160358547453e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s01729", + "operation": "hitting_probability", + "max_absolute_error": 1.7763568394002505e-15, + "max_relative_error": 1.7763568394002477e-15, + "passed": true + }, + { + "dataset": "absorbing-n0050-s01729", + "operation": "hitting_time", + "max_absolute_error": 1.1368683772161603e-13, + "max_relative_error": 4.2743258696347165e-15, + "passed": true + }, + { + "dataset": "absorbing-n0050-s01729", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0050-s01729", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 7.589415207398531e-19, + "max_relative_error": 9.101648414049397e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s01729", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.730113238767292e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s01729", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 5.551115123125783e-16, + "max_relative_error": 5.6716164898126e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s01729", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 3.2694616691055206e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s01729", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 1.249000902703301e-16, + "max_relative_error": 5.8786504338772846e-15, + "passed": true + }, + { + "dataset": "absorbing-n0050-s01729", + "operation": "return_bounded_10", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 1.736020582747689e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s01729", + "operation": "return_bounded_100", + "max_absolute_error": 1.6653345369377348e-16, + "max_relative_error": 4.915948313913868e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s01729", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.3317776655484448e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s01729", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 1.4210854715202004e-14, + "max_relative_error": 3.536057891046925e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s01729", + "operation": "stationary[48]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0050-s01729", + "operation": "stationary[49]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0050-s01729", + "operation": "fundamental", + "max_absolute_error": 8.881784197001252e-16, + "max_relative_error": 1.2975368920312316e-15, + "passed": true + }, + { + "dataset": "absorbing-n0050-s01729", + "operation": "absorption_probability", + "max_absolute_error": 5.551115123125783e-16, + "max_relative_error": 1.0523267087957055e-15, + "passed": true + }, + { + "dataset": "absorbing-n0050-s01729", + "operation": "absorption_time", + "max_absolute_error": 2.4868995751603507e-14, + "max_relative_error": 9.306889859330958e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s01729", + "operation": "occupation", + "max_absolute_error": 1.1102230246251565e-15, + "max_relative_error": 2.1583866668634553e-15, + "passed": true + }, + { + "dataset": "absorbing-n0050-s02718", + "operation": "evolve_1", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 4.0603922424569266e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s02718", + "operation": "evolve_10", + "max_absolute_error": 1.942890293094024e-16, + "max_relative_error": 1.1178787272362581e-15, + "passed": true + }, + { + "dataset": "absorbing-n0050-s02718", + "operation": "power_10", + "max_absolute_error": 1.3877787807814457e-16, + "max_relative_error": 1.4690238716200082e-15, + "passed": true + }, + { + "dataset": "absorbing-n0050-s02718", + "operation": "finite_time_step", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 2.556871138527214e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s02718", + "operation": "finite_time_n_step_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0050-s02718", + "operation": "finite_time_n_step_100", + "max_absolute_error": 3.885780586188048e-16, + "max_relative_error": 8.53648579043072e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s02718", + "operation": "finite_time_observation_10", + "max_absolute_error": 1.942890293094024e-16, + "max_relative_error": 1.1178787272362581e-15, + "passed": true + }, + { + "dataset": "absorbing-n0050-s02718", + "operation": "finite_time_observation_100", + "max_absolute_error": 6.661338147750939e-16, + "max_relative_error": 1.4564867524465104e-15, + "passed": true + }, + { + "dataset": "absorbing-n0050-s02718", + "operation": "hitting_probability", + "max_absolute_error": 3.6637359812630166e-15, + "max_relative_error": 3.66373598126301e-15, + "passed": true + }, + { + "dataset": "absorbing-n0050-s02718", + "operation": "hitting_time", + "max_absolute_error": 8.526512829121202e-14, + "max_relative_error": 3.3645749588371008e-15, + "passed": true + }, + { + "dataset": "absorbing-n0050-s02718", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 1.255329473044463e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s02718", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 3.0357660829594124e-18, + "max_relative_error": 4.0384029013408906e-15, + "passed": true + }, + { + "dataset": "absorbing-n0050-s02718", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.715113854087326e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s02718", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 8.881784197001252e-16, + "max_relative_error": 9.048235008191267e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s02718", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0050-s02718", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 1.8041124150158794e-16, + "max_relative_error": 9.807121392531616e-15, + "passed": true + }, + { + "dataset": "absorbing-n0050-s02718", + "operation": "return_bounded_10", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 1.858332904608587e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s02718", + "operation": "return_bounded_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0050-s02718", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0050-s02718", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 4.263256414560601e-14, + "max_relative_error": 1.229774433257493e-15, + "passed": true + }, + { + "dataset": "absorbing-n0050-s02718", + "operation": "stationary[48]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0050-s02718", + "operation": "stationary[49]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0050-s02718", + "operation": "fundamental", + "max_absolute_error": 1.3322676295501878e-15, + "max_relative_error": 2.0468090708038445e-15, + "passed": true + }, + { + "dataset": "absorbing-n0050-s02718", + "operation": "absorption_probability", + "max_absolute_error": 6.661338147750939e-16, + "max_relative_error": 1.4440732037673885e-15, + "passed": true + }, + { + "dataset": "absorbing-n0050-s02718", + "operation": "absorption_time", + "max_absolute_error": 3.552713678800501e-14, + "max_relative_error": 1.4041849296819453e-15, + "passed": true + }, + { + "dataset": "absorbing-n0050-s02718", + "operation": "occupation", + "max_absolute_error": 1.9984014443252818e-15, + "max_relative_error": 3.0002382185956934e-15, + "passed": true + }, + { + "dataset": "absorbing-n0050-s31415", + "operation": "evolve_1", + "max_absolute_error": 2.0816681711721685e-17, + "max_relative_error": 4.211021172297839e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s31415", + "operation": "evolve_10", + "max_absolute_error": 8.326672684688674e-17, + "max_relative_error": 4.751276369012442e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s31415", + "operation": "power_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.1698681953985039e-15, + "passed": true + }, + { + "dataset": "absorbing-n0050-s31415", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0050-s31415", + "operation": "finite_time_n_step_10", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 1.5740930969526479e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s31415", + "operation": "finite_time_n_step_100", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 2.0629059268467329e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s31415", + "operation": "finite_time_observation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0050-s31415", + "operation": "finite_time_observation_100", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 2.1310011050666434e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s31415", + "operation": "hitting_probability", + "max_absolute_error": 1.887379141862766e-15, + "max_relative_error": 1.887379141862765e-15, + "passed": true + }, + { + "dataset": "absorbing-n0050-s31415", + "operation": "hitting_time", + "max_absolute_error": 1.1368683772161603e-13, + "max_relative_error": 4.468410744559469e-15, + "passed": true + }, + { + "dataset": "absorbing-n0050-s31415", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 1.2718574862944394e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s31415", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 2.168404344971009e-19, + "max_relative_error": 2.6701429800291494e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s31415", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 3.525143582593678e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s31415", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 6.661338147750939e-16, + "max_relative_error": 6.800020177569456e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s31415", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 3.2412623741108817e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s31415", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 7.632783294297951e-17, + "max_relative_error": 3.742595957108596e-15, + "passed": true + }, + { + "dataset": "absorbing-n0050-s31415", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0050-s31415", + "operation": "return_bounded_100", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 9.97478780121247e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s31415", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0050-s31415", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 2.1316282072803006e-14, + "max_relative_error": 5.220865560908357e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s31415", + "operation": "stationary[48]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0050-s31415", + "operation": "stationary[49]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0050-s31415", + "operation": "fundamental", + "max_absolute_error": 8.881784197001252e-16, + "max_relative_error": 1.1700077069158736e-15, + "passed": true + }, + { + "dataset": "absorbing-n0050-s31415", + "operation": "absorption_probability", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 8.462357698164247e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s31415", + "operation": "absorption_time", + "max_absolute_error": 1.7763568394002505e-14, + "max_relative_error": 7.087742074516993e-16, + "passed": true + }, + { + "dataset": "absorbing-n0050-s31415", + "operation": "occupation", + "max_absolute_error": 1.3322676295501878e-15, + "max_relative_error": 1.674915289916511e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s01729", + "operation": "evolve_1", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 6.708859072529209e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s01729", + "operation": "evolve_10", + "max_absolute_error": 4.163336342344337e-17, + "max_relative_error": 9.796226795515062e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s01729", + "operation": "power_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 2.1228508898098987e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s01729", + "operation": "finite_time_step", + "max_absolute_error": 1.734723475976807e-18, + "max_relative_error": 1.6378901521746667e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s01729", + "operation": "finite_time_n_step_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 1.4680946508305548e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s01729", + "operation": "finite_time_n_step_100", + "max_absolute_error": 2.7755575615628914e-16, + "max_relative_error": 6.340680869933013e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s01729", + "operation": "finite_time_observation_10", + "max_absolute_error": 4.163336342344337e-17, + "max_relative_error": 4.2807857798003567e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s01729", + "operation": "finite_time_observation_100", + "max_absolute_error": 6.106226635438361e-16, + "max_relative_error": 1.4082941565839608e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s01729", + "operation": "hitting_probability", + "max_absolute_error": 2.220446049250313e-15, + "max_relative_error": 2.2204460492503048e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s01729", + "operation": "hitting_time", + "max_absolute_error": 2.1316282072803006e-13, + "max_relative_error": 4.472162175660624e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s01729", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 2.0060943807656236e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s01729", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 1.0842021724855044e-17, + "max_relative_error": 4.155037072759832e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s01729", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0100-s01729", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 1.1102230246251565e-15, + "max_relative_error": 1.2657469485287853e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s01729", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.363284176212065e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s01729", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 7.216449660063518e-16, + "max_relative_error": 5.873179448646698e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s01729", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0100-s01729", + "operation": "return_bounded_100", + "max_absolute_error": 1.6653345369377348e-16, + "max_relative_error": 5.615561418835439e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s01729", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 2.511778457209809e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s01729", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 2.1316282072803006e-14, + "max_relative_error": 7.395688092438008e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s01729", + "operation": "stationary[98]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0100-s01729", + "operation": "stationary[99]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0100-s01729", + "operation": "fundamental", + "max_absolute_error": 2.220446049250313e-15, + "max_relative_error": 3.692654802768357e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s01729", + "operation": "absorption_probability", + "max_absolute_error": 1.609823385706477e-15, + "max_relative_error": 3.254498832511802e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s01729", + "operation": "absorption_time", + "max_absolute_error": 1.4210854715202004e-13, + "max_relative_error": 2.9179157124180944e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s01729", + "operation": "occupation", + "max_absolute_error": 2.6645352591003757e-15, + "max_relative_error": 5.307045684235283e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s02718", + "operation": "evolve_1", + "max_absolute_error": 5.204170427930421e-18, + "max_relative_error": 5.247266320227933e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s02718", + "operation": "evolve_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.3164421058942835e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s02718", + "operation": "power_10", + "max_absolute_error": 1.6653345369377348e-16, + "max_relative_error": 2.505158250520969e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s02718", + "operation": "finite_time_step", + "max_absolute_error": 8.673617379884035e-19, + "max_relative_error": 1.4123987393923878e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s02718", + "operation": "finite_time_n_step_10", + "max_absolute_error": 6.938893903907228e-17, + "max_relative_error": 7.953743318933304e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s02718", + "operation": "finite_time_n_step_100", + "max_absolute_error": 1.3877787807814457e-15, + "max_relative_error": 3.178914985537134e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s02718", + "operation": "finite_time_observation_10", + "max_absolute_error": 4.163336342344337e-17, + "max_relative_error": 4.194228568624802e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s02718", + "operation": "finite_time_observation_100", + "max_absolute_error": 1.8318679906315083e-15, + "max_relative_error": 4.182837435602158e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s02718", + "operation": "hitting_probability", + "max_absolute_error": 3.774758283725532e-15, + "max_relative_error": 3.7747582837255275e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s02718", + "operation": "hitting_time", + "max_absolute_error": 1.1368683772161603e-13, + "max_relative_error": 2.2095461029169636e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s02718", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 1.734723475976807e-17, + "max_relative_error": 1.0568400357450322e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s02718", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 2.688821387764051e-17, + "max_relative_error": 9.512955545362954e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s02718", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 6.59301718268411e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s02718", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 3.4416913763379853e-15, + "max_relative_error": 4.016913686081359e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s02718", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 9.992007221626409e-16, + "max_relative_error": 1.2015310697895836e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s02718", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 1.2212453270876722e-15, + "max_relative_error": 8.52824548934792e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s02718", + "operation": "return_bounded_10", + "max_absolute_error": 6.938893903907228e-17, + "max_relative_error": 8.064966077050813e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s02718", + "operation": "return_bounded_100", + "max_absolute_error": 1.2212453270876722e-15, + "max_relative_error": 3.6076747382614796e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s02718", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 5.693644191089525e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s02718", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 7.460698725481052e-14, + "max_relative_error": 2.6481827628476465e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s02718", + "operation": "stationary[98]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0100-s02718", + "operation": "stationary[99]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0100-s02718", + "operation": "fundamental", + "max_absolute_error": 4.440892098500626e-15, + "max_relative_error": 6.56418000157212e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s02718", + "operation": "absorption_probability", + "max_absolute_error": 3.1086244689504383e-15, + "max_relative_error": 6.125666442645716e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s02718", + "operation": "absorption_time", + "max_absolute_error": 2.913225216616411e-13, + "max_relative_error": 5.6619618887247194e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s02718", + "operation": "occupation", + "max_absolute_error": 3.9968028886505635e-15, + "max_relative_error": 6.749343162932647e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s31415", + "operation": "evolve_1", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 3.707977893976398e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s31415", + "operation": "evolve_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 3.362517048049348e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s31415", + "operation": "power_10", + "max_absolute_error": 9.71445146547012e-17, + "max_relative_error": 1.8262599914061992e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s31415", + "operation": "finite_time_step", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 1.8672600209138712e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s31415", + "operation": "finite_time_n_step_10", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 2.6311012606362143e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s31415", + "operation": "finite_time_n_step_100", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 2.4501310365246647e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s31415", + "operation": "finite_time_observation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0100-s31415", + "operation": "finite_time_observation_100", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.2388398959435276e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s31415", + "operation": "hitting_probability", + "max_absolute_error": 1.887379141862766e-15, + "max_relative_error": 1.8873791418627645e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s31415", + "operation": "hitting_time", + "max_absolute_error": 2.1316282072803006e-13, + "max_relative_error": 4.591065186454664e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s31415", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 3.965855088506041e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s31415", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 3.0357660829594124e-18, + "max_relative_error": 1.2317210966968617e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s31415", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 2.704126497913059e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s31415", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 8.881784197001252e-16, + "max_relative_error": 1.0001419554085232e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s31415", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.3970044506893907e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s31415", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 3.191891195797325e-16, + "max_relative_error": 2.85123570081803e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s31415", + "operation": "return_bounded_10", + "max_absolute_error": 4.163336342344337e-17, + "max_relative_error": 4.772220010550544e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s31415", + "operation": "return_bounded_100", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 1.4329057504580527e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s31415", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 8.462388075250465e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s31415", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 1.0658141036401503e-14, + "max_relative_error": 3.5177188195826067e-16, + "passed": true + }, + { + "dataset": "absorbing-n0100-s31415", + "operation": "stationary[98]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0100-s31415", + "operation": "stationary[99]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "absorbing-n0100-s31415", + "operation": "fundamental", + "max_absolute_error": 8.881784197001252e-16, + "max_relative_error": 1.732379115035301e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s31415", + "operation": "absorption_probability", + "max_absolute_error": 6.661338147750939e-16, + "max_relative_error": 1.3060118563768717e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s31415", + "operation": "absorption_time", + "max_absolute_error": 4.973799150320701e-14, + "max_relative_error": 1.0861111459760533e-15, + "passed": true + }, + { + "dataset": "absorbing-n0100-s31415", + "operation": "occupation", + "max_absolute_error": 1.7763568394002505e-15, + "max_relative_error": 3.520218618224586e-15, + "passed": true + }, + { + "dataset": "dense-n0010-s01729", + "operation": "evolve_1", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 2.013445869813602e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s01729", + "operation": "evolve_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 7.91029433094602e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s01729", + "operation": "power_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 7.863106014971187e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s01729", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "dense-n0010-s01729", + "operation": "finite_time_n_step_10", + "max_absolute_error": 4.163336342344337e-17, + "max_relative_error": 4.635938356726418e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s01729", + "operation": "finite_time_n_step_100", + "max_absolute_error": 2.7755575615628914e-16, + "max_relative_error": 3.0906271442694387e-15, + "passed": true + }, + { + "dataset": "dense-n0010-s01729", + "operation": "finite_time_observation_10", + "max_absolute_error": 6.938893903907228e-17, + "max_relative_error": 7.726567641563874e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s01729", + "operation": "finite_time_observation_100", + "max_absolute_error": 3.0531133177191805e-16, + "max_relative_error": 3.3996898586963824e-15, + "passed": true + }, + { + "dataset": "dense-n0010-s01729", + "operation": "hitting_probability", + "max_absolute_error": 1.2212453270876722e-15, + "max_relative_error": 1.2212453270876708e-15, + "passed": true + }, + { + "dataset": "dense-n0010-s01729", + "operation": "hitting_time", + "max_absolute_error": 8.881784197001252e-15, + "max_relative_error": 9.05504306197197e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s01729", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 2.0816681711721685e-17, + "max_relative_error": 5.252584477405062e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s01729", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 2.625802136488331e-20, + "max_relative_error": 5.339204101468187e-15, + "passed": true + }, + { + "dataset": "dense-n0010-s01729", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "dense-n0010-s01729", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 7.771561172376096e-16, + "max_relative_error": 7.771924834776017e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s01729", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 5.888673457198266e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s01729", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 1.4521532847727725e-17, + "max_relative_error": 3.1034349935771644e-13, + "passed": true + }, + { + "dataset": "dense-n0010-s01729", + "operation": "return_bounded_10", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 3.302836776130817e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s01729", + "operation": "return_bounded_100", + "max_absolute_error": 5.551115123125783e-16, + "max_relative_error": 5.551168370405504e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s01729", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 2.8094694952773286e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s01729", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 1.5987211554602254e-14, + "max_relative_error": 1.8018121631786767e-15, + "passed": true + }, + { + "dataset": "dense-n0010-s01729", + "operation": "race_probability", + "max_absolute_error": 2.7755575615628914e-16, + "max_relative_error": 6.172536433197766e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s01729", + "operation": "return_mean", + "max_absolute_error": 7.105427357601002e-15, + "max_relative_error": 5.016217883263128e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s01729", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9]", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 4.1863495187605595e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s02718", + "operation": "evolve_1", + "max_absolute_error": 4.163336342344337e-17, + "max_relative_error": 3.759848055214247e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s02718", + "operation": "evolve_10", + "max_absolute_error": 8.326672684688674e-17, + "max_relative_error": 6.40651293720733e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s02718", + "operation": "power_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 5.061829298668041e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s02718", + "operation": "finite_time_step", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 2.1648177858856558e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s02718", + "operation": "finite_time_n_step_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 1.1135123964535767e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s02718", + "operation": "finite_time_n_step_100", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 1.1135124227745704e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s02718", + "operation": "finite_time_observation_10", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 2.227024845543344e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s02718", + "operation": "finite_time_observation_100", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 2.2270248455491407e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s02718", + "operation": "hitting_probability", + "max_absolute_error": 1.5543122344752192e-15, + "max_relative_error": 1.5543122344752178e-15, + "passed": true + }, + { + "dataset": "dense-n0010-s02718", + "operation": "hitting_time", + "max_absolute_error": 1.4210854715202004e-14, + "max_relative_error": 1.7713890421677783e-15, + "passed": true + }, + { + "dataset": "dense-n0010-s02718", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 2.0816681711721685e-17, + "max_relative_error": 5.127515625507554e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s02718", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 5.823351512373315e-22, + "max_relative_error": 2.154213998592677e-15, + "passed": true + }, + { + "dataset": "dense-n0010-s02718", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 4.6692980916925355e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s02718", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 3.330675431876945e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s02718", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.936295336959365e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s02718", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 3.822405581074481e-17, + "max_relative_error": 2.002389022618517e-11, + "passed": true + }, + { + "dataset": "dense-n0010-s02718", + "operation": "return_bounded_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.9370430176120547e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s02718", + "operation": "return_bounded_100", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 3.3311100507468474e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s02718", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 2.1097114830406846e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s02718", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 1.2434497875801753e-14, + "max_relative_error": 1.0134680709076695e-15, + "passed": true + }, + { + "dataset": "dense-n0010-s02718", + "operation": "race_probability", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 6.955120097420162e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s02718", + "operation": "return_mean", + "max_absolute_error": 5.329070518200751e-15, + "max_relative_error": 4.427773374405786e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s02718", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9]", + "max_absolute_error": 4.163336342344337e-17, + "max_relative_error": 3.6860311161628424e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s31415", + "operation": "evolve_1", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 3.0901391967826555e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s31415", + "operation": "evolve_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 5.615347326931155e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s31415", + "operation": "power_10", + "max_absolute_error": 8.326672684688674e-17, + "max_relative_error": 9.554821814786997e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s31415", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "dense-n0010-s31415", + "operation": "finite_time_n_step_10", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 3.3193730403745156e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s31415", + "operation": "finite_time_n_step_100", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.327749209910689e-15, + "passed": true + }, + { + "dataset": "dense-n0010-s31415", + "operation": "finite_time_observation_10", + "max_absolute_error": 4.163336342344337e-17, + "max_relative_error": 4.97905954323705e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s31415", + "operation": "finite_time_observation_100", + "max_absolute_error": 8.326672684688674e-17, + "max_relative_error": 9.958119074330168e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s31415", + "operation": "hitting_probability", + "max_absolute_error": 8.881784197001252e-16, + "max_relative_error": 8.881784197001248e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s31415", + "operation": "hitting_time", + "max_absolute_error": 7.105427357601002e-15, + "max_relative_error": 6.129294929994159e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s31415", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 3.376214452803825e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s31415", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 5.759824041329242e-20, + "max_relative_error": 2.9208721145445923e-15, + "passed": true + }, + { + "dataset": "dense-n0010-s31415", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 2.0705828585291088e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s31415", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 5.551115123125783e-16, + "max_relative_error": 5.552350571590653e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s31415", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "dense-n0010-s31415", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 2.5099280293039428e-17, + "max_relative_error": 1.1280114650203146e-13, + "passed": true + }, + { + "dataset": "dense-n0010-s31415", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "dense-n0010-s31415", + "operation": "return_bounded_100", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.1102541835273232e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s31415", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.651052393192816e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s31415", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 1.7763568394002505e-14, + "max_relative_error": 2.1668288037918327e-15, + "passed": true + }, + { + "dataset": "dense-n0010-s31415", + "operation": "race_probability", + "max_absolute_error": 1.6653345369377348e-16, + "max_relative_error": 3.3937441541151045e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s31415", + "operation": "return_mean", + "max_absolute_error": 3.552713678800501e-15, + "max_relative_error": 4.842361140563515e-16, + "passed": true + }, + { + "dataset": "dense-n0010-s31415", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9]", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 4.370171363525581e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s01729", + "operation": "evolve_1", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 2.0528977197716224e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s01729", + "operation": "evolve_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 3.7242772109345577e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s01729", + "operation": "power_10", + "max_absolute_error": 4.85722573273506e-17, + "max_relative_error": 1.1102982870437103e-15, + "passed": true + }, + { + "dataset": "dense-n0025-s01729", + "operation": "finite_time_step", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 1.4425808479641287e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s01729", + "operation": "finite_time_n_step_10", + "max_absolute_error": 2.0816681711721685e-17, + "max_relative_error": 4.875877618041844e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s01729", + "operation": "finite_time_n_step_100", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 6.501170170054864e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s01729", + "operation": "finite_time_observation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "dense-n0025-s01729", + "operation": "finite_time_observation_100", + "max_absolute_error": 2.0816681711721685e-17, + "max_relative_error": 4.87587762754115e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s01729", + "operation": "hitting_probability", + "max_absolute_error": 8.881784197001252e-16, + "max_relative_error": 8.881784197001248e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s01729", + "operation": "hitting_time", + "max_absolute_error": 1.0302869668521453e-13, + "max_relative_error": 4.362742058932115e-15, + "passed": true + }, + { + "dataset": "dense-n0025-s01729", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 1.0408340855860843e-17, + "max_relative_error": 3.576261424610166e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s01729", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 1.3010426069826053e-18, + "max_relative_error": 2.4689729274247677e-15, + "passed": true + }, + { + "dataset": "dense-n0025-s01729", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 3.0712958355032757e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s01729", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 5.551115123125783e-16, + "max_relative_error": 5.616042127787795e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s01729", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "dense-n0025-s01729", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 1.682681771697503e-16, + "max_relative_error": 1.455482470923587e-14, + "passed": true + }, + { + "dataset": "dense-n0025-s01729", + "operation": "return_bounded_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.6978941999609038e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s01729", + "operation": "return_bounded_100", + "max_absolute_error": 5.551115123125783e-16, + "max_relative_error": 5.639360936639363e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s01729", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.4304082681057395e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s01729", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 8.881784197001252e-16, + "max_relative_error": 2.0994807687963874e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s01729", + "operation": "race_probability", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 5.993431600839565e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s01729", + "operation": "return_mean", + "max_absolute_error": 1.7763568394002505e-14, + "max_relative_error": 7.16625584125692e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s01729", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24]", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 7.448554421528299e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s02718", + "operation": "evolve_1", + "max_absolute_error": 2.0816681711721685e-17, + "max_relative_error": 4.421589959953737e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s02718", + "operation": "evolve_10", + "max_absolute_error": 2.0816681711721685e-17, + "max_relative_error": 3.9817837434457012e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s02718", + "operation": "power_10", + "max_absolute_error": 3.469446951953614e-17, + "max_relative_error": 9.426629720699255e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s02718", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "dense-n0025-s02718", + "operation": "finite_time_n_step_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 3.77065188927497e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s02718", + "operation": "finite_time_n_step_100", + "max_absolute_error": 3.469446951953614e-17, + "max_relative_error": 9.426629724103092e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s02718", + "operation": "finite_time_observation_10", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 1.885325944720818e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s02718", + "operation": "finite_time_observation_100", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 7.541303779282474e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s02718", + "operation": "hitting_probability", + "max_absolute_error": 2.1094237467877974e-15, + "max_relative_error": 2.109423746787795e-15, + "passed": true + }, + { + "dataset": "dense-n0025-s02718", + "operation": "hitting_time", + "max_absolute_error": 5.684341886080802e-14, + "max_relative_error": 2.038350106324118e-15, + "passed": true + }, + { + "dataset": "dense-n0025-s02718", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 2.7491806570503003e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s02718", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 1.951563910473908e-18, + "max_relative_error": 2.0274684749939842e-15, + "passed": true + }, + { + "dataset": "dense-n0025-s02718", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "dense-n0025-s02718", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 8.881784197001252e-16, + "max_relative_error": 9.11926709993094e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s02718", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.625846414597349e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s02718", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 1.1796119636642288e-16, + "max_relative_error": 4.5296720051096585e-15, + "passed": true + }, + { + "dataset": "dense-n0025-s02718", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "dense-n0025-s02718", + "operation": "return_bounded_100", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 3.4753007895442353e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s02718", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.5940513373348682e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s02718", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 9.769962616701378e-15, + "max_relative_error": 2.6689027537126215e-15, + "passed": true + }, + { + "dataset": "dense-n0025-s02718", + "operation": "race_probability", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 6.082847887100297e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s02718", + "operation": "return_mean", + "max_absolute_error": 1.7763568394002505e-14, + "max_relative_error": 5.987236372899316e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s02718", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24]", + "max_absolute_error": 2.0816681711721685e-17, + "max_relative_error": 6.176114091571835e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s31415", + "operation": "evolve_1", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 2.87634768350821e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s31415", + "operation": "evolve_10", + "max_absolute_error": 3.469446951953614e-17, + "max_relative_error": 8.218139530000934e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s31415", + "operation": "power_10", + "max_absolute_error": 4.163336342344337e-17, + "max_relative_error": 1.2327209292913367e-15, + "passed": true + }, + { + "dataset": "dense-n0025-s31415", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "dense-n0025-s31415", + "operation": "finite_time_n_step_10", + "max_absolute_error": 2.0816681711721685e-17, + "max_relative_error": 5.218709300865216e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s31415", + "operation": "finite_time_n_step_100", + "max_absolute_error": 1.942890293094024e-16, + "max_relative_error": 4.870795339238119e-15, + "passed": true + }, + { + "dataset": "dense-n0025-s31415", + "operation": "finite_time_observation_10", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 6.95827905819107e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s31415", + "operation": "finite_time_observation_100", + "max_absolute_error": 1.8735013540549517e-16, + "max_relative_error": 4.696838362836759e-15, + "passed": true + }, + { + "dataset": "dense-n0025-s31415", + "operation": "hitting_probability", + "max_absolute_error": 5.329070518200751e-15, + "max_relative_error": 5.32907051820072e-15, + "passed": true + }, + { + "dataset": "dense-n0025-s31415", + "operation": "hitting_time", + "max_absolute_error": 5.684341886080802e-14, + "max_relative_error": 2.1768798300399807e-15, + "passed": true + }, + { + "dataset": "dense-n0025-s31415", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 2.0816681711721685e-17, + "max_relative_error": 7.523276453495087e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s31415", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 3.686287386450715e-18, + "max_relative_error": 4.897964273791674e-15, + "passed": true + }, + { + "dataset": "dense-n0025-s31415", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 3.438598306531348e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s31415", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 1.3322676295501878e-15, + "max_relative_error": 1.3572656423526777e-15, + "passed": true + }, + { + "dataset": "dense-n0025-s31415", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 3.27920592699539e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s31415", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 4.85722573273506e-17, + "max_relative_error": 2.6372278693830745e-15, + "passed": true + }, + { + "dataset": "dense-n0025-s31415", + "operation": "return_bounded_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 4.2586924889251753e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s31415", + "operation": "return_bounded_100", + "max_absolute_error": 1.6653345369377348e-15, + "max_relative_error": 1.746708347165938e-15, + "passed": true + }, + { + "dataset": "dense-n0025-s31415", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "dense-n0025-s31415", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 9.325873406851315e-15, + "max_relative_error": 2.368191163748832e-15, + "passed": true + }, + { + "dataset": "dense-n0025-s31415", + "operation": "race_probability", + "max_absolute_error": 5.551115123125783e-16, + "max_relative_error": 9.460122406126173e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s31415", + "operation": "return_mean", + "max_absolute_error": 1.7763568394002505e-14, + "max_relative_error": 6.015196915453759e-16, + "passed": true + }, + { + "dataset": "dense-n0025-s31415", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24]", + "max_absolute_error": 2.0816681711721685e-17, + "max_relative_error": 6.14740555495937e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s01729", + "operation": "evolve_1", + "max_absolute_error": 1.0408340855860843e-17, + "max_relative_error": 4.435383761787378e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s01729", + "operation": "evolve_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 6.62968091027631e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s01729", + "operation": "power_10", + "max_absolute_error": 2.42861286636753e-17, + "max_relative_error": 1.194950212096494e-15, + "passed": true + }, + { + "dataset": "dense-n0050-s01729", + "operation": "finite_time_step", + "max_absolute_error": 1.734723475976807e-18, + "max_relative_error": 1.1212402099321956e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s01729", + "operation": "finite_time_n_step_10", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 1.6456866877995605e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s01729", + "operation": "finite_time_n_step_100", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 3.2913733756779e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s01729", + "operation": "finite_time_observation_10", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 3.291373375671853e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s01729", + "operation": "finite_time_observation_100", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 6.5827467513558e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s01729", + "operation": "hitting_probability", + "max_absolute_error": 1.1102230246251565e-15, + "max_relative_error": 1.1102230246251556e-15, + "passed": true + }, + { + "dataset": "dense-n0050-s01729", + "operation": "hitting_time", + "max_absolute_error": 1.0302869668521453e-13, + "max_relative_error": 3.953190163678848e-15, + "passed": true + }, + { + "dataset": "dense-n0050-s01729", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 2.5574139025175257e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s01729", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "dense-n0050-s01729", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 3.641874183017799e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s01729", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.13537965493013e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s01729", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 4.791291119280503e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s01729", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 1.97758476261356e-16, + "max_relative_error": 8.925319003981865e-15, + "passed": true + }, + { + "dataset": "dense-n0050-s01729", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "dense-n0050-s01729", + "operation": "return_bounded_100", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.2847110556925795e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s01729", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 3.019457983317934e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s01729", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 2.1337820897483084e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s01729", + "operation": "race_probability", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 8.778217873910642e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s01729", + "operation": "return_mean", + "max_absolute_error": 4.973799150320701e-14, + "max_relative_error": 9.365850988833861e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s01729", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49]", + "max_absolute_error": 1.734723475976807e-17, + "max_relative_error": 9.212367526604326e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s02718", + "operation": "evolve_1", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 5.930461658498255e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s02718", + "operation": "evolve_10", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 3.384527480635139e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s02718", + "operation": "power_10", + "max_absolute_error": 3.122502256758253e-17, + "max_relative_error": 1.4568332332992069e-15, + "passed": true + }, + { + "dataset": "dense-n0050-s02718", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "dense-n0050-s02718", + "operation": "finite_time_n_step_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "dense-n0050-s02718", + "operation": "finite_time_n_step_100", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 3.716291439178016e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s02718", + "operation": "finite_time_observation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "dense-n0050-s02718", + "operation": "finite_time_observation_100", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 1.858145719589008e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s02718", + "operation": "hitting_probability", + "max_absolute_error": 2.7755575615628914e-15, + "max_relative_error": 2.7755575615628917e-15, + "passed": true + }, + { + "dataset": "dense-n0050-s02718", + "operation": "hitting_time", + "max_absolute_error": 3.907985046680551e-14, + "max_relative_error": 1.5171708932584998e-15, + "passed": true + }, + { + "dataset": "dense-n0050-s02718", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 1.2480421816580551e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s02718", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 8.673617379884035e-19, + "max_relative_error": 1.1161990208251815e-15, + "passed": true + }, + { + "dataset": "dense-n0050-s02718", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "dense-n0050-s02718", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.1319154646193783e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s02718", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 4.858080519526843e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s02718", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 1.4482909841913339e-15, + "passed": true + }, + { + "dataset": "dense-n0050-s02718", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "dense-n0050-s02718", + "operation": "return_bounded_100", + "max_absolute_error": 7.771561172376096e-16, + "max_relative_error": 9.122642705861863e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s02718", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 1.6531081857245102e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s02718", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 1.7763568394002505e-15, + "max_relative_error": 9.610556251334907e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s02718", + "operation": "race_probability", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 9.165576298773336e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s02718", + "operation": "return_mean", + "max_absolute_error": 6.394884621840902e-14, + "max_relative_error": 1.1624469727389897e-15, + "passed": true + }, + { + "dataset": "dense-n0050-s02718", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49]", + "max_absolute_error": 2.0816681711721685e-17, + "max_relative_error": 1.1451729057574464e-15, + "passed": true + }, + { + "dataset": "dense-n0050-s31415", + "operation": "evolve_1", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 3.394847303658104e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s31415", + "operation": "evolve_10", + "max_absolute_error": 1.0408340855860843e-17, + "max_relative_error": 5.829576665528097e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s31415", + "operation": "power_10", + "max_absolute_error": 3.122502256758253e-17, + "max_relative_error": 1.646243102466645e-15, + "passed": true + }, + { + "dataset": "dense-n0050-s31415", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "dense-n0050-s31415", + "operation": "finite_time_n_step_10", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 1.7034799138409495e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s31415", + "operation": "finite_time_n_step_100", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 3.406959827562922e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s31415", + "operation": "finite_time_observation_10", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 3.4069598275649347e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s31415", + "operation": "finite_time_observation_100", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 3.406959827562922e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s31415", + "operation": "hitting_probability", + "max_absolute_error": 1.9984014443252818e-15, + "max_relative_error": 1.9984014443252806e-15, + "passed": true + }, + { + "dataset": "dense-n0050-s31415", + "operation": "hitting_time", + "max_absolute_error": 3.552713678800501e-14, + "max_relative_error": 1.4713117142002512e-15, + "passed": true + }, + { + "dataset": "dense-n0050-s31415", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 1.2279442277018576e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s31415", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 6.505213034913027e-19, + "max_relative_error": 1.1004473685687849e-15, + "passed": true + }, + { + "dataset": "dense-n0050-s31415", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.55740721589982e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s31415", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 4.501504573733754e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s31415", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "dense-n0050-s31415", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 1.491862189340054e-16, + "max_relative_error": 1.1079607692747774e-14, + "passed": true + }, + { + "dataset": "dense-n0050-s31415", + "operation": "return_bounded_10", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 1.459171047750256e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s31415", + "operation": "return_bounded_100", + "max_absolute_error": 6.661338147750939e-16, + "max_relative_error": 7.605667677223315e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s31415", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "dense-n0050-s31415", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 3.552713678800501e-15, + "max_relative_error": 1.7487822070023676e-15, + "passed": true + }, + { + "dataset": "dense-n0050-s31415", + "operation": "race_probability", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 6.633334838809169e-16, + "passed": true + }, + { + "dataset": "dense-n0050-s31415", + "operation": "return_mean", + "max_absolute_error": 8.526512829121202e-14, + "max_relative_error": 1.6504691357025384e-15, + "passed": true + }, + { + "dataset": "dense-n0050-s31415", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49]", + "max_absolute_error": 3.122502256758253e-17, + "max_relative_error": 1.6131204743720527e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s01729", + "operation": "evolve_1", + "max_absolute_error": 5.204170427930421e-18, + "max_relative_error": 5.062558020811477e-16, + "passed": true + }, + { + "dataset": "dense-n0100-s01729", + "operation": "evolve_10", + "max_absolute_error": 5.204170427930421e-18, + "max_relative_error": 5.523758122402195e-16, + "passed": true + }, + { + "dataset": "dense-n0100-s01729", + "operation": "power_10", + "max_absolute_error": 2.6020852139652106e-17, + "max_relative_error": 2.52639749912214e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s01729", + "operation": "finite_time_step", + "max_absolute_error": 1.0842021724855044e-19, + "max_relative_error": 1.9163996200129614e-16, + "passed": true + }, + { + "dataset": "dense-n0100-s01729", + "operation": "finite_time_n_step_10", + "max_absolute_error": 1.734723475976807e-18, + "max_relative_error": 1.837265480311891e-16, + "passed": true + }, + { + "dataset": "dense-n0100-s01729", + "operation": "finite_time_n_step_100", + "max_absolute_error": 4.163336342344337e-17, + "max_relative_error": 4.409437152763351e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s01729", + "operation": "finite_time_observation_10", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 3.6745309606355205e-16, + "passed": true + }, + { + "dataset": "dense-n0100-s01729", + "operation": "finite_time_observation_100", + "max_absolute_error": 4.336808689942018e-17, + "max_relative_error": 4.593163700795157e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s01729", + "operation": "hitting_probability", + "max_absolute_error": 3.4416913763379853e-15, + "max_relative_error": 3.441691376337982e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s01729", + "operation": "hitting_time", + "max_absolute_error": 4.263256414560601e-14, + "max_relative_error": 2.1688368153993693e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s01729", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 2.1640159232225552e-16, + "passed": true + }, + { + "dataset": "dense-n0100-s01729", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 1.4094628242311558e-18, + "max_relative_error": 4.6806797905955145e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s01729", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "dense-n0100-s01729", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 7.771561172376096e-16, + "max_relative_error": 7.815770827668801e-16, + "passed": true + }, + { + "dataset": "dense-n0100-s01729", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 5.529693643645992e-16, + "passed": true + }, + { + "dataset": "dense-n0100-s01729", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 1.6479873021779667e-16, + "max_relative_error": 2.9134565731061246e-14, + "passed": true + }, + { + "dataset": "dense-n0100-s01729", + "operation": "return_bounded_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 1.371298999397355e-16, + "passed": true + }, + { + "dataset": "dense-n0100-s01729", + "operation": "return_bounded_100", + "max_absolute_error": 1.1102230246251565e-15, + "max_relative_error": 1.7646953971081685e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s01729", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "dense-n0100-s01729", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 2.4424906541753444e-15, + "max_relative_error": 2.639054502037325e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s01729", + "operation": "race_probability", + "max_absolute_error": 7.216449660063518e-16, + "max_relative_error": 1.4871607737984589e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s01729", + "operation": "return_mean", + "max_absolute_error": 1.9895196601282805e-13, + "max_relative_error": 1.6832686909849584e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s01729", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99]", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 1.6402688311501475e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s02718", + "operation": "evolve_1", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 7.420795622145993e-16, + "passed": true + }, + { + "dataset": "dense-n0100-s02718", + "operation": "evolve_10", + "max_absolute_error": 8.673617379884035e-18, + "max_relative_error": 8.945633238455964e-16, + "passed": true + }, + { + "dataset": "dense-n0100-s02718", + "operation": "power_10", + "max_absolute_error": 2.2551405187698492e-17, + "max_relative_error": 2.2287939799271997e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s02718", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "dense-n0100-s02718", + "operation": "finite_time_n_step_10", + "max_absolute_error": 1.734723475976807e-18, + "max_relative_error": 1.8397050720662077e-16, + "passed": true + }, + { + "dataset": "dense-n0100-s02718", + "operation": "finite_time_n_step_100", + "max_absolute_error": 2.2551405187698492e-17, + "max_relative_error": 2.391616593674015e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s02718", + "operation": "finite_time_observation_10", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 3.679410144114636e-16, + "passed": true + }, + { + "dataset": "dense-n0100-s02718", + "operation": "finite_time_observation_100", + "max_absolute_error": 1.9081958235744878e-17, + "max_relative_error": 2.0236755792626282e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s02718", + "operation": "hitting_probability", + "max_absolute_error": 1.2212453270876722e-15, + "max_relative_error": 1.2212453270876708e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s02718", + "operation": "hitting_time", + "max_absolute_error": 6.394884621840902e-14, + "max_relative_error": 3.2894225828864283e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s02718", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 2.2128689081275206e-16, + "passed": true + }, + { + "dataset": "dense-n0100-s02718", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 1.0299920638612292e-18, + "max_relative_error": 3.4810569843010558e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s02718", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "dense-n0100-s02718", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 1.1102230246251565e-15, + "max_relative_error": 1.1164347565744609e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s02718", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 3.7657289110992867e-16, + "passed": true + }, + { + "dataset": "dense-n0100-s02718", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 1.1015494072452725e-16, + "max_relative_error": 1.9798150570069178e-14, + "passed": true + }, + { + "dataset": "dense-n0100-s02718", + "operation": "return_bounded_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 1.5053052895510604e-16, + "passed": true + }, + { + "dataset": "dense-n0100-s02718", + "operation": "return_bounded_100", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 3.5387990114648164e-16, + "passed": true + }, + { + "dataset": "dense-n0100-s02718", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 1.4419423241212749e-16, + "passed": true + }, + { + "dataset": "dense-n0100-s02718", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 3.3306690738754696e-15, + "max_relative_error": 3.5249435765815275e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s02718", + "operation": "race_probability", + "max_absolute_error": 7.771561172376096e-16, + "max_relative_error": 1.5003212699003007e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s02718", + "operation": "return_mean", + "max_absolute_error": 1.5631940186722204e-13, + "max_relative_error": 1.435611856093991e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s02718", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99]", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 1.511110040049536e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s31415", + "operation": "evolve_1", + "max_absolute_error": 8.673617379884035e-18, + "max_relative_error": 8.357179315967336e-16, + "passed": true + }, + { + "dataset": "dense-n0100-s31415", + "operation": "evolve_10", + "max_absolute_error": 1.5612511283791264e-17, + "max_relative_error": 1.4460599636414244e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s31415", + "operation": "power_10", + "max_absolute_error": 2.6020852139652106e-17, + "max_relative_error": 2.4965588998115316e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s31415", + "operation": "finite_time_step", + "max_absolute_error": 2.6020852139652106e-18, + "max_relative_error": 3.524531610396578e-16, + "passed": true + }, + { + "dataset": "dense-n0100-s31415", + "operation": "finite_time_n_step_10", + "max_absolute_error": 8.673617379884035e-18, + "max_relative_error": 8.944165058858067e-16, + "passed": true + }, + { + "dataset": "dense-n0100-s31415", + "operation": "finite_time_n_step_100", + "max_absolute_error": 6.245004513516506e-17, + "max_relative_error": 6.439798842391039e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s31415", + "operation": "finite_time_observation_10", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 7.155332047099076e-16, + "passed": true + }, + { + "dataset": "dense-n0100-s31415", + "operation": "finite_time_observation_100", + "max_absolute_error": 6.245004513516506e-17, + "max_relative_error": 6.439798842391039e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s31415", + "operation": "hitting_probability", + "max_absolute_error": 3.552713678800501e-15, + "max_relative_error": 3.5527136788004946e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s31415", + "operation": "hitting_time", + "max_absolute_error": 8.526512829121202e-14, + "max_relative_error": 4.24928646398026e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s31415", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 8.794431162197484e-16, + "passed": true + }, + { + "dataset": "dense-n0100-s31415", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 1.6805133673525319e-18, + "max_relative_error": 5.243655534718245e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s31415", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 2.7755575615628914e-16, + "max_relative_error": 6.995014546950414e-16, + "passed": true + }, + { + "dataset": "dense-n0100-s31415", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 1.3322676295501878e-15, + "max_relative_error": 1.3404785747028987e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s31415", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 3.681054806107476e-16, + "passed": true + }, + { + "dataset": "dense-n0100-s31415", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 1.6653345369377348e-16, + "max_relative_error": 2.718743366274125e-14, + "passed": true + }, + { + "dataset": "dense-n0100-s31415", + "operation": "return_bounded_10", + "max_absolute_error": 8.326672684688674e-17, + "max_relative_error": 9.277589757957018e-16, + "passed": true + }, + { + "dataset": "dense-n0100-s31415", + "operation": "return_bounded_100", + "max_absolute_error": 2.3314683517128287e-15, + "max_relative_error": 3.791227807938629e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s31415", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 4.163336342344337e-17, + "max_relative_error": 4.923122539914235e-16, + "passed": true + }, + { + "dataset": "dense-n0100-s31415", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 2.1094237467877974e-15, + "max_relative_error": 2.2034140630934775e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s31415", + "operation": "race_probability", + "max_absolute_error": 6.661338147750939e-16, + "max_relative_error": 1.3318709456260279e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s31415", + "operation": "return_mean", + "max_absolute_error": 1.1368683772161603e-13, + "max_relative_error": 1.0884442910509099e-15, + "passed": true + }, + { + "dataset": "dense-n0100-s31415", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99]", + "max_absolute_error": 1.214306433183765e-17, + "max_relative_error": 1.1205128861850221e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s01729", + "operation": "evolve_1", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s01729", + "operation": "evolve_10", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 2.1591461359462238e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s01729", + "operation": "power_10", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 2.9293345308949626e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s01729", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s01729", + "operation": "finite_time_n_step_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 2.1006310694997545e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s01729", + "operation": "finite_time_n_step_100", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 7.810999677013306e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s01729", + "operation": "finite_time_observation_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 1.952719539851093e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s01729", + "operation": "finite_time_observation_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s01729", + "operation": "hitting_probability", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 3.3306690738754696e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s01729", + "operation": "hitting_time", + "max_absolute_error": 2.1316282072803006e-14, + "max_relative_error": 1.0549728824875375e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s01729", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s01729", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s01729", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s01729", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 3.336723983441559e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s01729", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 3.1542141617906666e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s01729", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 3.3393426912553537e-17, + "max_relative_error": 1.8402363776406388e-14, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s01729", + "operation": "return_bounded_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.3562102802120731e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s01729", + "operation": "return_bounded_100", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.1108311090066907e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s01729", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s01729", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 6.217248937900877e-15, + "max_relative_error": 9.300422781343793e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s01729", + "operation": "race_probability", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 3.808378654020294e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s01729", + "operation": "return_mean", + "max_absolute_error": 1.4210854715202004e-14, + "max_relative_error": 2.6556725181610704e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s01729", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9]", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 2.19483841929433e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s02718", + "operation": "evolve_1", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 2.896151757963492e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s02718", + "operation": "evolve_10", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 1.2988564611873076e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s02718", + "operation": "power_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 4.2610836253271227e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s02718", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s02718", + "operation": "finite_time_n_step_10", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 1.1610969433237936e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s02718", + "operation": "finite_time_n_step_100", + "max_absolute_error": 3.469446951953614e-17, + "max_relative_error": 1.1914550931988561e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s02718", + "operation": "finite_time_observation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s02718", + "operation": "finite_time_observation_100", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 4.765820372795428e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s02718", + "operation": "hitting_probability", + "max_absolute_error": 8.659739592076221e-15, + "max_relative_error": 8.6597395920762e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s02718", + "operation": "hitting_time", + "max_absolute_error": 4.192202140984591e-13, + "max_relative_error": 9.569105431829166e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s02718", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s02718", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 8.673617379884035e-19, + "max_relative_error": 4.561316813385032e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s02718", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s02718", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 2.401526751322663e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s02718", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 3.127560108009092e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s02718", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 5.689893001203927e-16, + "max_relative_error": 7.54604444215992e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s02718", + "operation": "return_bounded_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.5157039976366668e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s02718", + "operation": "return_bounded_100", + "max_absolute_error": 5.551115123125783e-16, + "max_relative_error": 5.551173448459214e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s02718", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 3.19677072145984e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s02718", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 1.3322676295501878e-15, + "max_relative_error": 4.485594084202438e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s02718", + "operation": "race_probability", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 4.1258243061983e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s02718", + "operation": "return_mean", + "max_absolute_error": 1.4210854715202004e-14, + "max_relative_error": 5.965606591763018e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s02718", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9]", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 4.958805695741574e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s31415", + "operation": "evolve_1", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 1.8811283927255793e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s31415", + "operation": "evolve_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 4.622433056934436e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s31415", + "operation": "power_10", + "max_absolute_error": 1.6653345369377348e-16, + "max_relative_error": 6.619668531707348e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s31415", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s31415", + "operation": "finite_time_n_step_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 3.810813135613418e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s31415", + "operation": "finite_time_n_step_100", + "max_absolute_error": 5.551115123125783e-16, + "max_relative_error": 1.905281374938524e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s31415", + "operation": "finite_time_observation_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 3.812189314846383e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s31415", + "operation": "finite_time_observation_100", + "max_absolute_error": 3.885780586188048e-16, + "max_relative_error": 1.3336969624569674e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s31415", + "operation": "hitting_probability", + "max_absolute_error": 7.771561172376096e-16, + "max_relative_error": 7.771561172376091e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s31415", + "operation": "hitting_time", + "max_absolute_error": 1.3322676295501878e-15, + "max_relative_error": 4.817441407263392e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s31415", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 2.6020852139652106e-18, + "max_relative_error": 4.123815878035966e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s31415", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 2.256949153578792e-35, + "max_relative_error": 2.528717921195548e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s31415", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 2.2449180365236515e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s31415", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s31415", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 8.673617379884035e-17, + "max_relative_error": 7.956673023943603e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s31415", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 1.54204052953822e-20, + "max_relative_error": 1.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s31415", + "operation": "return_bounded_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.4650310758298678e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s31415", + "operation": "return_bounded_100", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.1102236214561047e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s31415", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 1.5881661465169997e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s31415", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 7.105427357601002e-15, + "max_relative_error": 2.448608249421743e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s31415", + "operation": "race_probability", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 2.1466223586313742e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s31415", + "operation": "return_mean", + "max_absolute_error": 2.842170943040401e-14, + "max_relative_error": 5.663315957465499e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0010-s31415", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9]", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 5.22349170838543e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s01729", + "operation": "evolve_1", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 2.833363119117947e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s01729", + "operation": "evolve_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 5.891996652989976e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s01729", + "operation": "power_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 8.590646538636861e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s01729", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s01729", + "operation": "finite_time_n_step_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s01729", + "operation": "finite_time_n_step_100", + "max_absolute_error": 1.8735013540549517e-16, + "max_relative_error": 3.647780069489248e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s01729", + "operation": "finite_time_observation_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 2.640706631567983e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s01729", + "operation": "finite_time_observation_100", + "max_absolute_error": 1.8041124150158794e-16, + "max_relative_error": 3.512677071117972e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s01729", + "operation": "hitting_probability", + "max_absolute_error": 1.3322676295501878e-15, + "max_relative_error": 1.332267629550186e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s01729", + "operation": "hitting_time", + "max_absolute_error": 3.552713678800501e-14, + "max_relative_error": 1.5185942116014891e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s01729", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 2.5311345161898388e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s01729", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 3.673098181949813e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s01729", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 1.2248640800162918e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s01729", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 8.881784197001252e-16, + "max_relative_error": 9.09811601349314e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s01729", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 5.74204731202748e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s01729", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 3.400058012914542e-16, + "max_relative_error": 1.4299386357374693e-14, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s01729", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s01729", + "operation": "return_bounded_100", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 3.477383663344986e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s01729", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s01729", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 6.217248937900877e-15, + "max_relative_error": 1.2829732535920918e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s01729", + "operation": "race_probability", + "max_absolute_error": 6.661338147750939e-16, + "max_relative_error": 9.503389451211256e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s01729", + "operation": "return_mean", + "max_absolute_error": 1.8189894035458565e-12, + "max_relative_error": 7.295446257588598e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s01729", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24]", + "max_absolute_error": 6.938893903907228e-17, + "max_relative_error": 6.912672092676814e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s02718", + "operation": "evolve_1", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 4.323041893050063e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s02718", + "operation": "evolve_10", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 6.235060834908213e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s02718", + "operation": "power_10", + "max_absolute_error": 4.163336342344337e-17, + "max_relative_error": 5.937174268038702e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s02718", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s02718", + "operation": "finite_time_n_step_10", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 1.7376889501927038e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s02718", + "operation": "finite_time_n_step_100", + "max_absolute_error": 1.0408340855860843e-17, + "max_relative_error": 5.53182295000165e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s02718", + "operation": "finite_time_observation_10", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 3.7042756132125616e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s02718", + "operation": "finite_time_observation_100", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 7.375763933335532e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s02718", + "operation": "hitting_probability", + "max_absolute_error": 4.9960036108132044e-15, + "max_relative_error": 4.996003610813199e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s02718", + "operation": "hitting_time", + "max_absolute_error": 3.268496584496461e-13, + "max_relative_error": 3.766946048486635e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s02718", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 1.734723475976807e-18, + "max_relative_error": 1.6711810945880953e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s02718", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 4.336808689942018e-19, + "max_relative_error": 1.3419630242824052e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s02718", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s02718", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.498689241874452e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s02718", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 2.806853368296218e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s02718", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 2.7755575615628914e-16, + "max_relative_error": 1.0708005157236439e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s02718", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s02718", + "operation": "return_bounded_100", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 3.502877571518838e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s02718", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s02718", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s02718", + "operation": "race_probability", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 2.1724384410455807e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s02718", + "operation": "return_mean", + "max_absolute_error": 2.842170943040401e-14, + "max_relative_error": 4.0132159548790203e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s02718", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24]", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 4.435645628846066e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s31415", + "operation": "evolve_1", + "max_absolute_error": 4.163336342344337e-17, + "max_relative_error": 7.162294049434931e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s31415", + "operation": "evolve_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 7.4899213099286495e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s31415", + "operation": "power_10", + "max_absolute_error": 8.326672684688674e-17, + "max_relative_error": 8.267999771179086e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s31415", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s31415", + "operation": "finite_time_n_step_10", + "max_absolute_error": 4.163336342344337e-17, + "max_relative_error": 3.347622592781434e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s31415", + "operation": "finite_time_n_step_100", + "max_absolute_error": 2.0816681711721685e-16, + "max_relative_error": 1.719511318666558e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s31415", + "operation": "finite_time_observation_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 4.786149319529481e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s31415", + "operation": "finite_time_observation_100", + "max_absolute_error": 1.5265566588595902e-16, + "max_relative_error": 1.260974967022283e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s31415", + "operation": "hitting_probability", + "max_absolute_error": 1.9984014443252818e-15, + "max_relative_error": 1.998401444325278e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s31415", + "operation": "hitting_time", + "max_absolute_error": 1.7763568394002505e-14, + "max_relative_error": 1.079772203276529e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s31415", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 4.63582004819517e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s31415", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 1.6940658945086007e-20, + "max_relative_error": 1.5447945260932194e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s31415", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.62549780062521e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s31415", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 2.2207123292579586e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s31415", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.7511676961375961e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s31415", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 1.6115310041281417e-16, + "max_relative_error": 1.3439787693730962e-12, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s31415", + "operation": "return_bounded_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.697992456540012e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s31415", + "operation": "return_bounded_100", + "max_absolute_error": 1.2212453270876722e-15, + "max_relative_error": 1.3897550296915233e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s31415", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 1.956639765266611e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s31415", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 1.0658141036401503e-14, + "max_relative_error": 8.850146616926238e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s31415", + "operation": "race_probability", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 4.398270620610048e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s31415", + "operation": "return_mean", + "max_absolute_error": 9.094947017729282e-13, + "max_relative_error": 7.404833119379573e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0025-s31415", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24]", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 7.989993418856824e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s01729", + "operation": "evolve_1", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 2.1829002653435466e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s01729", + "operation": "evolve_10", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 4.2466661766033176e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s01729", + "operation": "power_10", + "max_absolute_error": 3.469446951953614e-17, + "max_relative_error": 1.1716015811331447e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s01729", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s01729", + "operation": "finite_time_n_step_10", + "max_absolute_error": 8.673617379884035e-19, + "max_relative_error": 1.7913779384702064e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s01729", + "operation": "finite_time_n_step_100", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 1.272864501691636e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s01729", + "operation": "finite_time_observation_10", + "max_absolute_error": 8.673617379884035e-19, + "max_relative_error": 1.5872297692062338e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s01729", + "operation": "finite_time_observation_100", + "max_absolute_error": 4.336808689942018e-18, + "max_relative_error": 7.9554031355727275e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s01729", + "operation": "hitting_probability", + "max_absolute_error": 2.708944180085382e-14, + "max_relative_error": 2.7089441800853608e-14, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s01729", + "operation": "hitting_time", + "max_absolute_error": 3.524291969370097e-12, + "max_relative_error": 1.5764683748984835e-14, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s01729", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s01729", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 3.0357660829594124e-18, + "max_relative_error": 1.0259464557395365e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s01729", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s01729", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 6.408679506781078e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s01729", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s01729", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 5.551115123125783e-16, + "max_relative_error": 8.494110485983424e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s01729", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s01729", + "operation": "return_bounded_100", + "max_absolute_error": 7.771561172376096e-16, + "max_relative_error": 1.0606038857106033e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s01729", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 1.9040698600751374e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s01729", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 4.3777863605977106e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s01729", + "operation": "race_probability", + "max_absolute_error": 4.996003610813204e-16, + "max_relative_error": 1.915278040571642e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s01729", + "operation": "return_mean", + "max_absolute_error": 4.547473508864641e-13, + "max_relative_error": 6.245134056156459e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s01729", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49]", + "max_absolute_error": 2.0816681711721685e-17, + "max_relative_error": 6.315804417707827e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s02718", + "operation": "evolve_1", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 4.295257489219149e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s02718", + "operation": "evolve_10", + "max_absolute_error": 2.0816681711721685e-17, + "max_relative_error": 5.029660424600079e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s02718", + "operation": "power_10", + "max_absolute_error": 4.163336342344337e-17, + "max_relative_error": 8.77080684517646e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s02718", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s02718", + "operation": "finite_time_n_step_10", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 1.8493578625493967e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s02718", + "operation": "finite_time_n_step_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s02718", + "operation": "finite_time_observation_10", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 1.8850395678115832e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s02718", + "operation": "finite_time_observation_100", + "max_absolute_error": 1.0408340855860843e-17, + "max_relative_error": 5.653980997106711e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s02718", + "operation": "hitting_probability", + "max_absolute_error": 3.552713678800501e-15, + "max_relative_error": 3.552713678800503e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s02718", + "operation": "hitting_time", + "max_absolute_error": 3.552713678800501e-13, + "max_relative_error": 5.1062772907963696e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s02718", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 1.734723475976807e-18, + "max_relative_error": 1.5884933365702547e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s02718", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 8.673617379884035e-19, + "max_relative_error": 3.176722442067815e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s02718", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.7991376370208317e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s02718", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 4.091408486430832e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s02718", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.6056286836891477e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s02718", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 3.885780586188048e-16, + "max_relative_error": 2.0898504013791893e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s02718", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s02718", + "operation": "return_bounded_100", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 4.1818321090354865e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s02718", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.3721215943349176e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s02718", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 2.1525135955682356e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s02718", + "operation": "race_probability", + "max_absolute_error": 1.6653345369377348e-16, + "max_relative_error": 6.906037837784168e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s02718", + "operation": "return_mean", + "max_absolute_error": 7.275957614183426e-11, + "max_relative_error": 9.181705763077618e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s02718", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49]", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 8.591659606358292e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s31415", + "operation": "evolve_1", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 4.3133715939242475e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s31415", + "operation": "evolve_10", + "max_absolute_error": 3.469446951953614e-17, + "max_relative_error": 7.214983836546589e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s31415", + "operation": "power_10", + "max_absolute_error": 3.469446951953614e-17, + "max_relative_error": 7.956665578309718e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s31415", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s31415", + "operation": "finite_time_n_step_10", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 1.635873498543808e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s31415", + "operation": "finite_time_n_step_100", + "max_absolute_error": 3.122502256758253e-17, + "max_relative_error": 1.5483411922381536e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s31415", + "operation": "finite_time_observation_10", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 1.740356424245909e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s31415", + "operation": "finite_time_observation_100", + "max_absolute_error": 4.163336342344337e-17, + "max_relative_error": 2.064454922984202e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s31415", + "operation": "hitting_probability", + "max_absolute_error": 8.326672684688674e-15, + "max_relative_error": 8.326672684688665e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s31415", + "operation": "hitting_time", + "max_absolute_error": 2.4868995751603507e-13, + "max_relative_error": 4.071631663873679e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s31415", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 1.964011683636326e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s31415", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 3.0357660829594124e-18, + "max_relative_error": 9.168135942391122e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s31415", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s31415", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.3635575872404077e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s31415", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 2.426530889367422e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s31415", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 3.608224830031759e-16, + "max_relative_error": 1.9421046590201153e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s31415", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s31415", + "operation": "return_bounded_100", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 3.915064262273671e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s31415", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 4.133216404122205e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s31415", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 2.3572043212786235e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s31415", + "operation": "race_probability", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 8.198301375356126e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s31415", + "operation": "return_mean", + "max_absolute_error": 9.094947017729282e-13, + "max_relative_error": 5.662669753778529e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0050-s31415", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49]", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 5.224087794639367e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s01729", + "operation": "evolve_1", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 3.603528964452635e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s01729", + "operation": "evolve_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 1.0059579995924855e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s01729", + "operation": "power_10", + "max_absolute_error": 3.469446951953614e-17, + "max_relative_error": 1.206251421091361e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s01729", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s01729", + "operation": "finite_time_n_step_10", + "max_absolute_error": 1.734723475976807e-18, + "max_relative_error": 1.5811464128534932e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s01729", + "operation": "finite_time_n_step_100", + "max_absolute_error": 3.2959746043559335e-17, + "max_relative_error": 2.600056718189528e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s01729", + "operation": "finite_time_observation_10", + "max_absolute_error": 5.204170427930421e-18, + "max_relative_error": 4.16197564078463e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s01729", + "operation": "finite_time_observation_100", + "max_absolute_error": 3.2959746043559335e-17, + "max_relative_error": 2.6000567181896444e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s01729", + "operation": "hitting_probability", + "max_absolute_error": 2.886579864025407e-15, + "max_relative_error": 2.886579864025404e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s01729", + "operation": "hitting_time", + "max_absolute_error": 6.750155989720952e-14, + "max_relative_error": 2.391743775172928e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s01729", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 4.425239450918851e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s01729", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 1.0842021724855044e-18, + "max_relative_error": 1.6335953539203796e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s01729", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 3.4595968474443467e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s01729", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 6.661338147750939e-16, + "max_relative_error": 6.757367911460143e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s01729", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.3224112476984036e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s01729", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 1.4051260155412137e-16, + "max_relative_error": 9.887510998910777e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s01729", + "operation": "return_bounded_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 2.574598357204403e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s01729", + "operation": "return_bounded_100", + "max_absolute_error": 7.771561172376096e-16, + "max_relative_error": 1.2530141292324398e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s01729", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 2.182563325255774e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s01729", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 8.881784197001252e-16, + "max_relative_error": 7.598046751075141e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s01729", + "operation": "race_probability", + "max_absolute_error": 1.2212453270876722e-15, + "max_relative_error": 1.7575551014679721e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s01729", + "operation": "return_mean", + "max_absolute_error": 2.7284841053187847e-12, + "max_relative_error": 1.2559054337827795e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s01729", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99]", + "max_absolute_error": 2.0816681711721685e-17, + "max_relative_error": 1.236613733309544e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s02718", + "operation": "evolve_1", + "max_absolute_error": 1.734723475976807e-17, + "max_relative_error": 7.515764205626314e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s02718", + "operation": "evolve_10", + "max_absolute_error": 3.469446951953614e-17, + "max_relative_error": 9.786294846080306e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s02718", + "operation": "power_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.0743322537792638e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s02718", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s02718", + "operation": "finite_time_n_step_10", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 3.946449099733264e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s02718", + "operation": "finite_time_n_step_100", + "max_absolute_error": 2.2551405187698492e-17, + "max_relative_error": 2.3761488961477575e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s02718", + "operation": "finite_time_observation_10", + "max_absolute_error": 5.204170427930421e-18, + "max_relative_error": 5.545136910376215e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s02718", + "operation": "finite_time_observation_100", + "max_absolute_error": 2.0816681711721685e-17, + "max_relative_error": 2.193368211828615e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s02718", + "operation": "hitting_probability", + "max_absolute_error": 2.1094237467877974e-15, + "max_relative_error": 2.109423746787793e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s02718", + "operation": "hitting_time", + "max_absolute_error": 7.460698725481052e-14, + "max_relative_error": 4.136262068246709e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s02718", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 1.0408340855860843e-17, + "max_relative_error": 3.489359574108312e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s02718", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 4.607859233063394e-19, + "max_relative_error": 2.0194786614772403e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s02718", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 1.6653345369377348e-16, + "max_relative_error": 3.582796778235958e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s02718", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 3.344432204313732e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s02718", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s02718", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 1.3704315460216776e-16, + "max_relative_error": 3.330140200938625e-14, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s02718", + "operation": "return_bounded_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.788723128738628e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s02718", + "operation": "return_bounded_100", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 5.13327991872554e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s02718", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 4.858717909780888e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s02718", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 1.1102230246251565e-15, + "max_relative_error": 1.1485229813329624e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s02718", + "operation": "race_probability", + "max_absolute_error": 5.551115123125783e-16, + "max_relative_error": 8.030338874450665e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s02718", + "operation": "return_mean", + "max_absolute_error": 1.0913936421275139e-11, + "max_relative_error": 1.164371977847846e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s02718", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99]", + "max_absolute_error": 1.734723475976807e-17, + "max_relative_error": 1.1432796416321954e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s31415", + "operation": "evolve_1", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 3.237674920014695e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s31415", + "operation": "evolve_10", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 3.6745708043110084e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s31415", + "operation": "power_10", + "max_absolute_error": 2.0816681711721685e-17, + "max_relative_error": 1.2479823914103038e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s31415", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s31415", + "operation": "finite_time_n_step_10", + "max_absolute_error": 6.505213034913027e-19, + "max_relative_error": 3.8855848293658567e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s31415", + "operation": "finite_time_n_step_100", + "max_absolute_error": 5.204170427930421e-18, + "max_relative_error": 2.071465325261793e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s31415", + "operation": "finite_time_observation_10", + "max_absolute_error": 4.336808689942018e-19, + "max_relative_error": 1.7527537358396495e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s31415", + "operation": "finite_time_observation_100", + "max_absolute_error": 4.336808689942018e-18, + "max_relative_error": 1.7262211043833238e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s31415", + "operation": "hitting_probability", + "max_absolute_error": 6.217248937900877e-15, + "max_relative_error": 6.217248937900836e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s31415", + "operation": "hitting_time", + "max_absolute_error": 1.1368683772161603e-13, + "max_relative_error": 2.4818061381941155e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s31415", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 4.2038846225713733e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s31415", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 5.637851296924623e-18, + "max_relative_error": 1.997160748447007e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s31415", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 1.504262526366642e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s31415", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 5.551115123125783e-16, + "max_relative_error": 6.357168211619724e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s31415", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 2.4461159544288086e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s31415", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 1.6653345369377348e-16, + "max_relative_error": 1.3134137107164674e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s31415", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s31415", + "operation": "return_bounded_100", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 7.6568173552282805e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s31415", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s31415", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 2.498001805406602e-16, + "max_relative_error": 1.0142332073953378e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s31415", + "operation": "race_probability", + "max_absolute_error": 1.6653345369377348e-16, + "max_relative_error": 4.717719478074091e-16, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s31415", + "operation": "return_mean", + "max_absolute_error": 2.1827872842550278e-11, + "max_relative_error": 1.3398338013611921e-15, + "passed": true + }, + { + "dataset": "low-outdegree-n0100-s31415", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99]", + "max_absolute_error": 2.0816681711721685e-17, + "max_relative_error": 1.3247441846474113e-15, + "passed": true + }, + { + "dataset": "periodic-n0010-s01729", + "operation": "evolve_1", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s01729", + "operation": "evolve_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s01729", + "operation": "power_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s01729", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s01729", + "operation": "finite_time_n_step_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s01729", + "operation": "finite_time_n_step_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s01729", + "operation": "finite_time_observation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s01729", + "operation": "finite_time_observation_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s01729", + "operation": "hitting_probability", + "max_absolute_error": 1.1102230246251565e-15, + "max_relative_error": 1.1102230246251565e-15, + "passed": true + }, + { + "dataset": "periodic-n0010-s01729", + "operation": "hitting_time", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s01729", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s01729", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s01729", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s01729", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s01729", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s01729", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s01729", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s01729", + "operation": "return_bounded_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s01729", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s01729", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s01729", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s02718", + "operation": "evolve_1", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 2.0693192921906383e-16, + "passed": true + }, + { + "dataset": "periodic-n0010-s02718", + "operation": "evolve_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 2.778716090793688e-16, + "passed": true + }, + { + "dataset": "periodic-n0010-s02718", + "operation": "power_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s02718", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s02718", + "operation": "finite_time_n_step_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s02718", + "operation": "finite_time_n_step_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s02718", + "operation": "finite_time_observation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s02718", + "operation": "finite_time_observation_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s02718", + "operation": "hitting_probability", + "max_absolute_error": 1.1102230246251565e-15, + "max_relative_error": 1.1102230246251565e-15, + "passed": true + }, + { + "dataset": "periodic-n0010-s02718", + "operation": "hitting_time", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s02718", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s02718", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s02718", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s02718", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s02718", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s02718", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s02718", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s02718", + "operation": "return_bounded_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s02718", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s02718", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s02718", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s31415", + "operation": "evolve_1", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s31415", + "operation": "evolve_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 2.909334435025607e-16, + "passed": true + }, + { + "dataset": "periodic-n0010-s31415", + "operation": "power_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s31415", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s31415", + "operation": "finite_time_n_step_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s31415", + "operation": "finite_time_n_step_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s31415", + "operation": "finite_time_observation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s31415", + "operation": "finite_time_observation_100", + "max_absolute_error": 2.0816681711721685e-17, + "max_relative_error": 5.236801983046091e-16, + "passed": true + }, + { + "dataset": "periodic-n0010-s31415", + "operation": "hitting_probability", + "max_absolute_error": 1.1102230246251565e-15, + "max_relative_error": 1.1102230246251565e-15, + "passed": true + }, + { + "dataset": "periodic-n0010-s31415", + "operation": "hitting_time", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s31415", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s31415", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s31415", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s31415", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s31415", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s31415", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s31415", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s31415", + "operation": "return_bounded_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s31415", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s31415", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0010-s31415", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s01729", + "operation": "evolve_1", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s01729", + "operation": "evolve_10", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 1.4597331559469626e-16, + "passed": true + }, + { + "dataset": "periodic-n0025-s01729", + "operation": "power_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s01729", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s01729", + "operation": "finite_time_n_step_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s01729", + "operation": "finite_time_n_step_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s01729", + "operation": "finite_time_observation_10", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 1.2736227842978107e-16, + "passed": true + }, + { + "dataset": "periodic-n0025-s01729", + "operation": "finite_time_observation_100", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 1.9126376760735284e-16, + "passed": true + }, + { + "dataset": "periodic-n0025-s01729", + "operation": "hitting_probability", + "max_absolute_error": 4.6629367034256575e-15, + "max_relative_error": 4.662936703425635e-15, + "passed": true + }, + { + "dataset": "periodic-n0025-s01729", + "operation": "hitting_time", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s01729", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s01729", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s01729", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s01729", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s01729", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s01729", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s01729", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s01729", + "operation": "return_bounded_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s01729", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s01729", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s01729", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s02718", + "operation": "evolve_1", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 2.1012188653125069e-16, + "passed": true + }, + { + "dataset": "periodic-n0025-s02718", + "operation": "evolve_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 2.953986261949077e-16, + "passed": true + }, + { + "dataset": "periodic-n0025-s02718", + "operation": "power_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s02718", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s02718", + "operation": "finite_time_n_step_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s02718", + "operation": "finite_time_n_step_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s02718", + "operation": "finite_time_observation_10", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 1.5740964856060824e-16, + "passed": true + }, + { + "dataset": "periodic-n0025-s02718", + "operation": "finite_time_observation_100", + "max_absolute_error": 6.071532165918825e-18, + "max_relative_error": 8.469141463779535e-16, + "passed": true + }, + { + "dataset": "periodic-n0025-s02718", + "operation": "hitting_probability", + "max_absolute_error": 4.6629367034256575e-15, + "max_relative_error": 4.662936703425635e-15, + "passed": true + }, + { + "dataset": "periodic-n0025-s02718", + "operation": "hitting_time", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s02718", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s02718", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s02718", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s02718", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s02718", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s02718", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s02718", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s02718", + "operation": "return_bounded_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s02718", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s02718", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s02718", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s31415", + "operation": "evolve_1", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s31415", + "operation": "evolve_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 2.680560799783209e-16, + "passed": true + }, + { + "dataset": "periodic-n0025-s31415", + "operation": "power_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s31415", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s31415", + "operation": "finite_time_n_step_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s31415", + "operation": "finite_time_n_step_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s31415", + "operation": "finite_time_observation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s31415", + "operation": "finite_time_observation_100", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 1.60261286250384e-16, + "passed": true + }, + { + "dataset": "periodic-n0025-s31415", + "operation": "hitting_probability", + "max_absolute_error": 4.6629367034256575e-15, + "max_relative_error": 4.662936703425635e-15, + "passed": true + }, + { + "dataset": "periodic-n0025-s31415", + "operation": "hitting_time", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s31415", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s31415", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s31415", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s31415", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s31415", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s31415", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s31415", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s31415", + "operation": "return_bounded_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s31415", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s31415", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0025-s31415", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s01729", + "operation": "evolve_1", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s01729", + "operation": "evolve_10", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 2.913733105100766e-16, + "passed": true + }, + { + "dataset": "periodic-n0050-s01729", + "operation": "power_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s01729", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s01729", + "operation": "finite_time_n_step_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s01729", + "operation": "finite_time_n_step_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s01729", + "operation": "finite_time_observation_10", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 1.7666423879347802e-16, + "passed": true + }, + { + "dataset": "periodic-n0050-s01729", + "operation": "finite_time_observation_100", + "max_absolute_error": 3.469446951953614e-17, + "max_relative_error": 1.0296382015570795e-15, + "passed": true + }, + { + "dataset": "periodic-n0050-s01729", + "operation": "hitting_probability", + "max_absolute_error": 6.217248937900877e-15, + "max_relative_error": 6.217248937900838e-15, + "passed": true + }, + { + "dataset": "periodic-n0050-s01729", + "operation": "hitting_time", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s01729", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s01729", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s01729", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s01729", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s01729", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s01729", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s01729", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s01729", + "operation": "return_bounded_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s01729", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s01729", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s01729", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s02718", + "operation": "evolve_1", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 2.9408482282888006e-16, + "passed": true + }, + { + "dataset": "periodic-n0050-s02718", + "operation": "evolve_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 4.3981435556997685e-16, + "passed": true + }, + { + "dataset": "periodic-n0050-s02718", + "operation": "power_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s02718", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s02718", + "operation": "finite_time_n_step_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s02718", + "operation": "finite_time_n_step_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s02718", + "operation": "finite_time_observation_10", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 2.648344506657926e-16, + "passed": true + }, + { + "dataset": "periodic-n0050-s02718", + "operation": "finite_time_observation_100", + "max_absolute_error": 2.0816681711721685e-17, + "max_relative_error": 9.564894723075219e-16, + "passed": true + }, + { + "dataset": "periodic-n0050-s02718", + "operation": "hitting_probability", + "max_absolute_error": 6.217248937900877e-15, + "max_relative_error": 6.217248937900838e-15, + "passed": true + }, + { + "dataset": "periodic-n0050-s02718", + "operation": "hitting_time", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s02718", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s02718", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s02718", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s02718", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s02718", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s02718", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s02718", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s02718", + "operation": "return_bounded_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s02718", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s02718", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s02718", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s31415", + "operation": "evolve_1", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 2.2131517942030788e-16, + "passed": true + }, + { + "dataset": "periodic-n0050-s31415", + "operation": "evolve_10", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 1.4662130636595396e-16, + "passed": true + }, + { + "dataset": "periodic-n0050-s31415", + "operation": "power_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s31415", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s31415", + "operation": "finite_time_n_step_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s31415", + "operation": "finite_time_n_step_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s31415", + "operation": "finite_time_observation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s31415", + "operation": "finite_time_observation_100", + "max_absolute_error": 2.0816681711721685e-17, + "max_relative_error": 5.761960109819943e-16, + "passed": true + }, + { + "dataset": "periodic-n0050-s31415", + "operation": "hitting_probability", + "max_absolute_error": 6.217248937900877e-15, + "max_relative_error": 6.217248937900838e-15, + "passed": true + }, + { + "dataset": "periodic-n0050-s31415", + "operation": "hitting_time", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s31415", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s31415", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s31415", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s31415", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s31415", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s31415", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s31415", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s31415", + "operation": "return_bounded_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s31415", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s31415", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0050-s31415", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s01729", + "operation": "evolve_1", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s01729", + "operation": "evolve_10", + "max_absolute_error": 1.734723475976807e-18, + "max_relative_error": 1.4308267517494463e-16, + "passed": true + }, + { + "dataset": "periodic-n0100-s01729", + "operation": "power_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s01729", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s01729", + "operation": "finite_time_n_step_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s01729", + "operation": "finite_time_n_step_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s01729", + "operation": "finite_time_observation_10", + "max_absolute_error": 1.734723475976807e-18, + "max_relative_error": 1.1564494627065838e-16, + "passed": true + }, + { + "dataset": "periodic-n0100-s01729", + "operation": "finite_time_observation_100", + "max_absolute_error": 5.204170427930421e-18, + "max_relative_error": 4.96427086430143e-16, + "passed": true + }, + { + "dataset": "periodic-n0100-s01729", + "operation": "hitting_probability", + "max_absolute_error": 4.618527782440651e-14, + "max_relative_error": 4.618527782440438e-14, + "passed": true + }, + { + "dataset": "periodic-n0100-s01729", + "operation": "hitting_time", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s01729", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s01729", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s01729", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s01729", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s01729", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s01729", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s01729", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s01729", + "operation": "return_bounded_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s01729", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s01729", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s01729", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s02718", + "operation": "evolve_1", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 2.952505562636589e-16, + "passed": true + }, + { + "dataset": "periodic-n0100-s02718", + "operation": "evolve_10", + "max_absolute_error": 5.204170427930421e-18, + "max_relative_error": 4.4287583439548837e-16, + "passed": true + }, + { + "dataset": "periodic-n0100-s02718", + "operation": "power_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s02718", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s02718", + "operation": "finite_time_n_step_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s02718", + "operation": "finite_time_n_step_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s02718", + "operation": "finite_time_observation_10", + "max_absolute_error": 5.204170427930421e-18, + "max_relative_error": 3.3728554690337603e-16, + "passed": true + }, + { + "dataset": "periodic-n0100-s02718", + "operation": "finite_time_observation_100", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 4.1836517351428463e-16, + "passed": true + }, + { + "dataset": "periodic-n0100-s02718", + "operation": "hitting_probability", + "max_absolute_error": 4.618527782440651e-14, + "max_relative_error": 4.618527782440438e-14, + "passed": true + }, + { + "dataset": "periodic-n0100-s02718", + "operation": "hitting_time", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s02718", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s02718", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s02718", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s02718", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s02718", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s02718", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s02718", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s02718", + "operation": "return_bounded_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s02718", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s02718", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s02718", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s31415", + "operation": "evolve_1", + "max_absolute_error": 1.0408340855860843e-17, + "max_relative_error": 5.325144084031733e-16, + "passed": true + }, + { + "dataset": "periodic-n0100-s31415", + "operation": "evolve_10", + "max_absolute_error": 1.0408340855860843e-17, + "max_relative_error": 5.325144084031733e-16, + "passed": true + }, + { + "dataset": "periodic-n0100-s31415", + "operation": "power_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s31415", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s31415", + "operation": "finite_time_n_step_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s31415", + "operation": "finite_time_n_step_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s31415", + "operation": "finite_time_observation_10", + "max_absolute_error": 8.131516293641283e-20, + "max_relative_error": 4.935118882564565e-16, + "passed": true + }, + { + "dataset": "periodic-n0100-s31415", + "operation": "finite_time_observation_100", + "max_absolute_error": 1.734723475976807e-18, + "max_relative_error": 2.499288692258218e-16, + "passed": true + }, + { + "dataset": "periodic-n0100-s31415", + "operation": "hitting_probability", + "max_absolute_error": 4.618527782440651e-14, + "max_relative_error": 4.618527782440438e-14, + "passed": true + }, + { + "dataset": "periodic-n0100-s31415", + "operation": "hitting_time", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s31415", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s31415", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s31415", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s31415", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s31415", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s31415", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s31415", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s31415", + "operation": "return_bounded_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s31415", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s31415", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "periodic-n0100-s31415", + "operation": "stationary[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0010-s01729", + "operation": "evolve_1", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 2.5871978045304704e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s01729", + "operation": "evolve_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 6.394345634938737e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s01729", + "operation": "power_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 3.9153668994578583e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s01729", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0010-s01729", + "operation": "finite_time_n_step_10", + "max_absolute_error": 1.6653345369377348e-16, + "max_relative_error": 4.0384294565448884e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s01729", + "operation": "finite_time_n_step_100", + "max_absolute_error": 2.220446049250313e-15, + "max_relative_error": 5.280007397021889e-15, + "passed": true + }, + { + "dataset": "reducible-n0010-s01729", + "operation": "finite_time_observation_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 3.0026651525894515e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s01729", + "operation": "finite_time_observation_100", + "max_absolute_error": 1.3322676295501878e-15, + "max_relative_error": 3.557068514271876e-15, + "passed": true + }, + { + "dataset": "reducible-n0010-s01729", + "operation": "hitting_probability", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 7.076637776635905e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s01729", + "operation": "hitting_time", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0010-s01729", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 2.6020852139652106e-18, + "max_relative_error": 3.7260179209821303e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s01729", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 2.2186712959340957e-31, + "max_relative_error": 2.660151409342166e-15, + "passed": true + }, + { + "dataset": "reducible-n0010-s01729", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.8163980261345424e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s01729", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 7.07663777663591e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s01729", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 2.8556758681459107e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s01729", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 2.275957200481571e-15, + "max_relative_error": 6.110652039209234e-15, + "passed": true + }, + { + "dataset": "reducible-n0010-s01729", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0010-s01729", + "operation": "return_bounded_100", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 1.5387057757361344e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s01729", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 1.4185498031729612e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s01729", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 4.263256414560601e-14, + "max_relative_error": 1.0410426653956035e-15, + "passed": true + }, + { + "dataset": "reducible-n0010-s01729", + "operation": "stationary[6,7]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0010-s01729", + "operation": "stationary[8,9]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0010-s01729", + "operation": "occupation", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 4.962013814428275e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s02718", + "operation": "evolve_1", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0010-s02718", + "operation": "evolve_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 4.472885961628904e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s02718", + "operation": "power_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 4.048857110329126e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s02718", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0010-s02718", + "operation": "finite_time_n_step_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 3.5164838972908663e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s02718", + "operation": "finite_time_n_step_100", + "max_absolute_error": 7.216449660063518e-16, + "max_relative_error": 2.5041898980310823e-15, + "passed": true + }, + { + "dataset": "reducible-n0010-s02718", + "operation": "finite_time_observation_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 2.148961877972632e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s02718", + "operation": "finite_time_observation_100", + "max_absolute_error": 3.885780586188048e-16, + "max_relative_error": 1.600685465051001e-15, + "passed": true + }, + { + "dataset": "reducible-n0010-s02718", + "operation": "hitting_probability", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 4.131096338708529e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s02718", + "operation": "hitting_time", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0010-s02718", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 1.734723475976807e-18, + "max_relative_error": 1.6437713252238732e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s02718", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 3.1554436208840472e-30, + "max_relative_error": 1.826783147669558e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s02718", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.2607475319960946e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s02718", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 2.360719572629541e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s02718", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.9836160558940676e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s02718", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 1.5543122344752192e-15, + "max_relative_error": 2.934270646135634e-15, + "passed": true + }, + { + "dataset": "reducible-n0010-s02718", + "operation": "return_bounded_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.5816535344234675e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s02718", + "operation": "return_bounded_100", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.571403025130572e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s02718", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 8.881784197001252e-16, + "max_relative_error": 4.0947580690493704e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s02718", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 3.552713678800501e-15, + "max_relative_error": 1.255676911456697e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s02718", + "operation": "stationary[6,7]", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.8118395341721518e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s02718", + "operation": "stationary[8,9]", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.6847042874920978e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s02718", + "operation": "occupation", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 5.196504061680074e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s31415", + "operation": "evolve_1", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 3.0594784195706314e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s31415", + "operation": "evolve_10", + "max_absolute_error": 8.326672684688674e-17, + "max_relative_error": 1.0721411984534032e-15, + "passed": true + }, + { + "dataset": "reducible-n0010-s31415", + "operation": "power_10", + "max_absolute_error": 1.6653345369377348e-16, + "max_relative_error": 1.1401290532739116e-15, + "passed": true + }, + { + "dataset": "reducible-n0010-s31415", + "operation": "finite_time_step", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 1.6794054549933714e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s31415", + "operation": "finite_time_n_step_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0010-s31415", + "operation": "finite_time_n_step_100", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.865095473824256e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s31415", + "operation": "finite_time_observation_10", + "max_absolute_error": 8.326672684688674e-17, + "max_relative_error": 3.5601922425243967e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s31415", + "operation": "finite_time_observation_100", + "max_absolute_error": 3.0531133177191805e-16, + "max_relative_error": 1.2716058289636584e-15, + "passed": true + }, + { + "dataset": "reducible-n0010-s31415", + "operation": "hitting_probability", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 5.882439683119201e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s31415", + "operation": "hitting_time", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0010-s31415", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 1.0408340855860843e-17, + "max_relative_error": 9.958403732987137e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s31415", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 4.1809627976713626e-29, + "max_relative_error": 7.687534633319669e-15, + "passed": true + }, + { + "dataset": "reducible-n0010-s31415", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 4.342032003475741e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s31415", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 4.1143067202896917e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s31415", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 6.816538204804472e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s31415", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 1.7763568394002505e-15, + "max_relative_error": 3.859036197190776e-15, + "passed": true + }, + { + "dataset": "reducible-n0010-s31415", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0010-s31415", + "operation": "return_bounded_100", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 3.8106077973267e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s31415", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0010-s31415", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 1.0658141036401503e-14, + "max_relative_error": 3.705517039275895e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s31415", + "operation": "stationary[6,7]", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 2.0131429948597237e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s31415", + "operation": "stationary[8,9]", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.9836994199290415e-16, + "passed": true + }, + { + "dataset": "reducible-n0010-s31415", + "operation": "occupation", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 7.861509102235718e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s01729", + "operation": "evolve_1", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 2.011478076613324e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s01729", + "operation": "evolve_10", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 4.56657068206324e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s01729", + "operation": "power_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 9.681561315319137e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s01729", + "operation": "finite_time_step", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 1.5901200339868e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s01729", + "operation": "finite_time_n_step_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0025-s01729", + "operation": "finite_time_n_step_100", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 8.122544525158994e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s01729", + "operation": "finite_time_observation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0025-s01729", + "operation": "finite_time_observation_100", + "max_absolute_error": 5.551115123125783e-16, + "max_relative_error": 1.2510397520284737e-15, + "passed": true + }, + { + "dataset": "reducible-n0025-s01729", + "operation": "hitting_probability", + "max_absolute_error": 9.43689570931383e-16, + "max_relative_error": 2.1311211975018112e-15, + "passed": true + }, + { + "dataset": "reducible-n0025-s01729", + "operation": "hitting_time", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0025-s01729", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 1.9121337930532215e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s01729", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 7.411538288475128e-22, + "max_relative_error": 1.106433220222399e-15, + "passed": true + }, + { + "dataset": "reducible-n0025-s01729", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.7678405574580206e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s01729", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0025-s01729", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.6184136915106873e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s01729", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 2.0755315133964955e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s01729", + "operation": "return_bounded_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 2.5779089952612197e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s01729", + "operation": "return_bounded_100", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 4.0801908066223965e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s01729", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 2.903065682237489e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s01729", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 3.552713678800501e-14, + "max_relative_error": 9.544965672424222e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s01729", + "operation": "stationary[21,22]", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 1.1727315636806711e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s01729", + "operation": "stationary[23,24]", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 1.6798463353560582e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s01729", + "operation": "occupation", + "max_absolute_error": 8.881784197001252e-16, + "max_relative_error": 1.3756161539374593e-15, + "passed": true + }, + { + "dataset": "reducible-n0025-s02718", + "operation": "evolve_1", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 3.1568507856007307e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s02718", + "operation": "evolve_10", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 2.3037337986339386e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s02718", + "operation": "power_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 8.80638670713305e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s02718", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0025-s02718", + "operation": "finite_time_n_step_10", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 2.686706598735767e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s02718", + "operation": "finite_time_n_step_100", + "max_absolute_error": 3.885780586188048e-16, + "max_relative_error": 2.653012450172921e-15, + "passed": true + }, + { + "dataset": "reducible-n0025-s02718", + "operation": "finite_time_observation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0025-s02718", + "operation": "finite_time_observation_100", + "max_absolute_error": 2.7755575615628914e-16, + "max_relative_error": 1.9264108460332424e-15, + "passed": true + }, + { + "dataset": "reducible-n0025-s02718", + "operation": "hitting_probability", + "max_absolute_error": 6.106226635438361e-16, + "max_relative_error": 1.4369853729906196e-15, + "passed": true + }, + { + "dataset": "reducible-n0025-s02718", + "operation": "hitting_time", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0025-s02718", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 1.976053153518749e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s02718", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 5.082197683525802e-21, + "max_relative_error": 1.5731120888615955e-15, + "passed": true + }, + { + "dataset": "reducible-n0025-s02718", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.8226833473053656e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s02718", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 2.314819797383744e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s02718", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.5964263033588007e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s02718", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 6.661338147750939e-16, + "max_relative_error": 1.2800795893026773e-15, + "passed": true + }, + { + "dataset": "reducible-n0025-s02718", + "operation": "return_bounded_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 2.183759260877724e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s02718", + "operation": "return_bounded_100", + "max_absolute_error": 1.6653345369377348e-16, + "max_relative_error": 5.072675600391731e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s02718", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0025-s02718", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 1.7763568394002505e-15, + "max_relative_error": 1.325785063213395e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s02718", + "operation": "stationary[21,22]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0025-s02718", + "operation": "stationary[23,24]", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.7059297806901899e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s02718", + "operation": "occupation", + "max_absolute_error": 6.661338147750939e-16, + "max_relative_error": 1.1399896956885137e-15, + "passed": true + }, + { + "dataset": "reducible-n0025-s31415", + "operation": "evolve_1", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 2.032809123395651e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s31415", + "operation": "evolve_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 7.118796976535465e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s31415", + "operation": "power_10", + "max_absolute_error": 1.3877787807814457e-16, + "max_relative_error": 1.3331374733323726e-15, + "passed": true + }, + { + "dataset": "reducible-n0025-s31415", + "operation": "finite_time_step", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 1.5526516444811216e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s31415", + "operation": "finite_time_n_step_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0025-s31415", + "operation": "finite_time_n_step_100", + "max_absolute_error": 3.0531133177191805e-16, + "max_relative_error": 2.173934660494125e-15, + "passed": true + }, + { + "dataset": "reducible-n0025-s31415", + "operation": "finite_time_observation_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 1.5428314345202876e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s31415", + "operation": "finite_time_observation_100", + "max_absolute_error": 3.608224830031759e-16, + "max_relative_error": 2.848765936874671e-15, + "passed": true + }, + { + "dataset": "reducible-n0025-s31415", + "operation": "hitting_probability", + "max_absolute_error": 5.551115123125783e-16, + "max_relative_error": 1.0344738933695897e-15, + "passed": true + }, + { + "dataset": "reducible-n0025-s31415", + "operation": "hitting_time", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0025-s31415", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 3.494844807928144e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s31415", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 1.0164395367051604e-19, + "max_relative_error": 5.361840488775665e-15, + "passed": true + }, + { + "dataset": "reducible-n0025-s31415", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.6088313105941692e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s31415", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 3.3306690738754696e-16, + "max_relative_error": 5.626447987653278e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s31415", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 3.3902021517909977e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s31415", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 2.7209118723324553e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s31415", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0025-s31415", + "operation": "return_bounded_100", + "max_absolute_error": 1.6653345369377348e-16, + "max_relative_error": 4.719802275844881e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s31415", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0025-s31415", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 1.5987211554602254e-14, + "max_relative_error": 1.2465434852288202e-15, + "passed": true + }, + { + "dataset": "reducible-n0025-s31415", + "operation": "stationary[21,22]", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0025-s31415", + "operation": "stationary[23,24]", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.7483023418375835e-16, + "passed": true + }, + { + "dataset": "reducible-n0025-s31415", + "operation": "occupation", + "max_absolute_error": 1.1102230246251565e-15, + "max_relative_error": 1.7791375421185112e-15, + "passed": true + }, + { + "dataset": "reducible-n0050-s01729", + "operation": "evolve_1", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 3.409588711720664e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s01729", + "operation": "evolve_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.0633965045730647e-15, + "passed": true + }, + { + "dataset": "reducible-n0050-s01729", + "operation": "power_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.4850254149520866e-15, + "passed": true + }, + { + "dataset": "reducible-n0050-s01729", + "operation": "finite_time_step", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 1.6036719893976596e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s01729", + "operation": "finite_time_n_step_10", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 4.723999336653392e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s01729", + "operation": "finite_time_n_step_100", + "max_absolute_error": 1.942890293094024e-16, + "max_relative_error": 1.6250050398263457e-15, + "passed": true + }, + { + "dataset": "reducible-n0050-s01729", + "operation": "finite_time_observation_10", + "max_absolute_error": 4.163336342344337e-17, + "max_relative_error": 5.603439801669019e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s01729", + "operation": "finite_time_observation_100", + "max_absolute_error": 2.7755575615628914e-16, + "max_relative_error": 2.3073949634908417e-15, + "passed": true + }, + { + "dataset": "reducible-n0050-s01729", + "operation": "hitting_probability", + "max_absolute_error": 3.219646771412954e-15, + "max_relative_error": 5.810145762230879e-15, + "passed": true + }, + { + "dataset": "reducible-n0050-s01729", + "operation": "hitting_time", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0050-s01729", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 1.734723475976807e-17, + "max_relative_error": 9.75438606997106e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s01729", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 8.131516293641283e-19, + "max_relative_error": 4.037923510116926e-15, + "passed": true + }, + { + "dataset": "reducible-n0050-s01729", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 5.090505081280169e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s01729", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 6.661338147750939e-16, + "max_relative_error": 1.184168572487844e-15, + "passed": true + }, + { + "dataset": "reducible-n0050-s01729", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0050-s01729", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 2.7755575615628914e-16, + "max_relative_error": 6.344609095431106e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s01729", + "operation": "return_bounded_10", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 1.5177899979316186e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s01729", + "operation": "return_bounded_100", + "max_absolute_error": 3.885780586188048e-16, + "max_relative_error": 1.138604479866992e-15, + "passed": true + }, + { + "dataset": "reducible-n0050-s01729", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 1.6653345369377348e-16, + "max_relative_error": 4.1174372113800353e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s01729", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 1.0658141036401503e-14, + "max_relative_error": 1.0647855354770888e-15, + "passed": true + }, + { + "dataset": "reducible-n0050-s01729", + "operation": "stationary[40,41,42,43,44]", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 2.517967469568862e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s01729", + "operation": "stationary[45,46,47,48,49]", + "max_absolute_error": 8.326672684688674e-17, + "max_relative_error": 4.38205957058328e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s01729", + "operation": "occupation", + "max_absolute_error": 1.7763568394002505e-15, + "max_relative_error": 3.5309167130081526e-15, + "passed": true + }, + { + "dataset": "reducible-n0050-s02718", + "operation": "evolve_1", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 2.121888994357412e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s02718", + "operation": "evolve_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 5.879453827938613e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s02718", + "operation": "power_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.207321926307005e-15, + "passed": true + }, + { + "dataset": "reducible-n0050-s02718", + "operation": "finite_time_step", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 1.9634211027722511e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s02718", + "operation": "finite_time_n_step_10", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 2.7386913422072736e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s02718", + "operation": "finite_time_n_step_100", + "max_absolute_error": 2.0816681711721685e-17, + "max_relative_error": 4.651941617107668e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s02718", + "operation": "finite_time_observation_10", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 2.5107559969388113e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s02718", + "operation": "finite_time_observation_100", + "max_absolute_error": 3.469446951953614e-17, + "max_relative_error": 8.02045559685395e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s02718", + "operation": "hitting_probability", + "max_absolute_error": 2.55351295663786e-15, + "max_relative_error": 4.581396894102921e-15, + "passed": true + }, + { + "dataset": "reducible-n0050-s02718", + "operation": "hitting_time", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0050-s02718", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 4.2863394578526957e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s02718", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 6.776263578034403e-19, + "max_relative_error": 2.9304430064396193e-15, + "passed": true + }, + { + "dataset": "reducible-n0050-s02718", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 8.326672684688674e-17, + "max_relative_error": 3.8932028548064983e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s02718", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 4.0817896291824044e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s02718", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 5.649107258530316e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s02718", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 5.551115123125783e-16, + "max_relative_error": 1.217318736006764e-15, + "passed": true + }, + { + "dataset": "reducible-n0050-s02718", + "operation": "return_bounded_10", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 1.717529963949394e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s02718", + "operation": "return_bounded_100", + "max_absolute_error": 3.885780586188048e-16, + "max_relative_error": 1.2429883600072272e-15, + "passed": true + }, + { + "dataset": "reducible-n0050-s02718", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 4.8406724948368235e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s02718", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 8.881784197001252e-16, + "max_relative_error": 2.2878800869967835e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s02718", + "operation": "stationary[40,41,42,43,44]", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 3.3837300163808877e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s02718", + "operation": "stationary[45,46,47,48,49]", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 4.220485160062159e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s02718", + "operation": "occupation", + "max_absolute_error": 1.7763568394002505e-15, + "max_relative_error": 2.1326192195239178e-15, + "passed": true + }, + { + "dataset": "reducible-n0050-s31415", + "operation": "evolve_1", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 4.316979355366417e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s31415", + "operation": "evolve_10", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 6.746894984132899e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s31415", + "operation": "power_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.2332521601235045e-15, + "passed": true + }, + { + "dataset": "reducible-n0050-s31415", + "operation": "finite_time_step", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0050-s31415", + "operation": "finite_time_n_step_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0050-s31415", + "operation": "finite_time_n_step_100", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.0433197503352377e-15, + "passed": true + }, + { + "dataset": "reducible-n0050-s31415", + "operation": "finite_time_observation_10", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 1.8411154538218937e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s31415", + "operation": "finite_time_observation_100", + "max_absolute_error": 8.326672684688674e-17, + "max_relative_error": 1.50364310185974e-15, + "passed": true + }, + { + "dataset": "reducible-n0050-s31415", + "operation": "hitting_probability", + "max_absolute_error": 7.771561172376096e-16, + "max_relative_error": 1.551508375438955e-15, + "passed": true + }, + { + "dataset": "reducible-n0050-s31415", + "operation": "hitting_time", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0050-s31415", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0050-s31415", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 1.0842021724855044e-19, + "max_relative_error": 6.18463289147736e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s31415", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 2.6416143082131156e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s31415", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 2.141442077214008e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s31415", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 2.811192999999468e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s31415", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 6.106226635438361e-16, + "max_relative_error": 1.2680264796606779e-15, + "passed": true + }, + { + "dataset": "reducible-n0050-s31415", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0050-s31415", + "operation": "return_bounded_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0050-s31415", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 2.1800533080750666e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s31415", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 1.7763568394002505e-15, + "max_relative_error": 3.8416942446409493e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s31415", + "operation": "stationary[40,41,42,43,44]", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 2.444355195970782e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s31415", + "operation": "stationary[45,46,47,48,49]", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 3.577773940585011e-16, + "passed": true + }, + { + "dataset": "reducible-n0050-s31415", + "operation": "occupation", + "max_absolute_error": 1.2212453270876722e-15, + "max_relative_error": 2.1979080570800063e-15, + "passed": true + }, + { + "dataset": "reducible-n0100-s01729", + "operation": "evolve_1", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 5.189125419168494e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s01729", + "operation": "evolve_10", + "max_absolute_error": 1.734723475976807e-17, + "max_relative_error": 7.137019882503498e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s01729", + "operation": "power_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.6621714648462807e-15, + "passed": true + }, + { + "dataset": "reducible-n0100-s01729", + "operation": "finite_time_step", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 1.767678762576983e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s01729", + "operation": "finite_time_n_step_10", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 1.9118815110596462e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s01729", + "operation": "finite_time_n_step_100", + "max_absolute_error": 1.214306433183765e-17, + "max_relative_error": 9.935597984474187e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s01729", + "operation": "finite_time_observation_10", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 1.6801496365007724e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s01729", + "operation": "finite_time_observation_100", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 2.853842153106963e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s01729", + "operation": "hitting_probability", + "max_absolute_error": 2.55351295663786e-15, + "max_relative_error": 5.078959322995052e-15, + "passed": true + }, + { + "dataset": "reducible-n0100-s01729", + "operation": "hitting_time", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0100-s01729", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 1.734723475976807e-18, + "max_relative_error": 1.7002969367268148e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s01729", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 8.673617379884035e-19, + "max_relative_error": 8.498368762078865e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s01729", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 1.1481192166213435e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s01729", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 2.7755575615628914e-16, + "max_relative_error": 5.840249626546662e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s01729", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 5.051485917132315e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s01729", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 5.551115123125783e-16, + "max_relative_error": 1.0578517298743523e-15, + "passed": true + }, + { + "dataset": "reducible-n0100-s01729", + "operation": "return_bounded_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 1.363192904226167e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s01729", + "operation": "return_bounded_100", + "max_absolute_error": 2.7755575615628914e-16, + "max_relative_error": 8.332887173980938e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s01729", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 8.326672684688674e-17, + "max_relative_error": 4.646203946562999e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s01729", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 4.440892098500626e-16, + "max_relative_error": 3.350438147024241e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s01729", + "operation": "stationary[80,81,82,83,84,85,86,87,88,89]", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 2.9245135526678093e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s01729", + "operation": "stationary[90,91,92,93,94,95,96,97,98,99]", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 2.1996020962076475e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s01729", + "operation": "occupation", + "max_absolute_error": 1.7763568394002505e-15, + "max_relative_error": 3.135733718233541e-15, + "passed": true + }, + { + "dataset": "reducible-n0100-s02718", + "operation": "evolve_1", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 5.852715508267666e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s02718", + "operation": "evolve_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 4.851113274533715e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s02718", + "operation": "power_10", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 2.4659936361478926e-15, + "passed": true + }, + { + "dataset": "reducible-n0100-s02718", + "operation": "finite_time_step", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 2.1993527338945812e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s02718", + "operation": "finite_time_n_step_10", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 2.707768994418201e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s02718", + "operation": "finite_time_n_step_100", + "max_absolute_error": 2.0816681711721685e-17, + "max_relative_error": 6.800978306100704e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s02718", + "operation": "finite_time_observation_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0100-s02718", + "operation": "finite_time_observation_100", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 4.546288386315261e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s02718", + "operation": "hitting_probability", + "max_absolute_error": 2.886579864025407e-15, + "max_relative_error": 5.938340622596604e-15, + "passed": true + }, + { + "dataset": "reducible-n0100-s02718", + "operation": "hitting_time", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0100-s02718", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 6.938893903907228e-18, + "max_relative_error": 7.682633307051576e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s02718", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 1.951563910473908e-18, + "max_relative_error": 1.7449084574866569e-15, + "passed": true + }, + { + "dataset": "reducible-n0100-s02718", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 1.3224204808198229e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s02718", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 5.551115123125783e-16, + "max_relative_error": 1.2560136544239755e-15, + "passed": true + }, + { + "dataset": "reducible-n0100-s02718", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0100-s02718", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 1.1102230246251565e-15, + "max_relative_error": 1.98951493311809e-15, + "passed": true + }, + { + "dataset": "reducible-n0100-s02718", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0100-s02718", + "operation": "return_bounded_100", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0100-s02718", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 2.144047147570049e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s02718", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 1.3322676295501878e-15, + "max_relative_error": 5.723608572197463e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s02718", + "operation": "stationary[80,81,82,83,84,85,86,87,88,89]", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 2.7093684537214094e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s02718", + "operation": "stationary[90,91,92,93,94,95,96,97,98,99]", + "max_absolute_error": 5.551115123125783e-17, + "max_relative_error": 1.481815290563897e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s02718", + "operation": "occupation", + "max_absolute_error": 1.9984014443252818e-15, + "max_relative_error": 3.6255716770403634e-15, + "passed": true + }, + { + "dataset": "reducible-n0100-s31415", + "operation": "evolve_1", + "max_absolute_error": 1.0408340855860843e-17, + "max_relative_error": 6.485929672625364e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s31415", + "operation": "evolve_10", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 6.452583728390348e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s31415", + "operation": "power_10", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 1.8212588610360833e-15, + "passed": true + }, + { + "dataset": "reducible-n0100-s31415", + "operation": "finite_time_step", + "max_absolute_error": 2.168404344971009e-19, + "max_relative_error": 1.1307325157213405e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s31415", + "operation": "finite_time_n_step_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0100-s31415", + "operation": "finite_time_n_step_100", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 5.164018886561277e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s31415", + "operation": "finite_time_observation_10", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 4.603177159391941e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s31415", + "operation": "finite_time_observation_100", + "max_absolute_error": 3.469446951953614e-17, + "max_relative_error": 6.185761416407708e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s31415", + "operation": "hitting_probability", + "max_absolute_error": 9.992007221626409e-16, + "max_relative_error": 2.0031675980760458e-15, + "passed": true + }, + { + "dataset": "reducible-n0100-s31415", + "operation": "hitting_time", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0100-s31415", + "operation": "hitting_bounded_exact_10", + "max_absolute_error": 3.469446951953614e-18, + "max_relative_error": 3.2981324421698183e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s31415", + "operation": "hitting_bounded_exact_100", + "max_absolute_error": 1.734723475976807e-18, + "max_relative_error": 1.7510904295187668e-15, + "passed": true + }, + { + "dataset": "reducible-n0100-s31415", + "operation": "hitting_bounded_at_most_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0100-s31415", + "operation": "hitting_bounded_at_most_100", + "max_absolute_error": 2.220446049250313e-16, + "max_relative_error": 4.769651406674546e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s31415", + "operation": "hitting_bounded_greater_than_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0100-s31415", + "operation": "hitting_bounded_greater_than_100", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 2.0772656842665662e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s31415", + "operation": "return_bounded_10", + "max_absolute_error": 0.0, + "max_relative_error": 0.0, + "passed": true + }, + { + "dataset": "reducible-n0100-s31415", + "operation": "return_bounded_100", + "max_absolute_error": 1.6653345369377348e-16, + "max_relative_error": 5.261529905048627e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s31415", + "operation": "visits_bounded_expectation_10", + "max_absolute_error": 2.7755575615628914e-17, + "max_relative_error": 1.797477902512475e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s31415", + "operation": "visits_bounded_expectation_100", + "max_absolute_error": 1.3322676295501878e-15, + "max_relative_error": 3.339532272428933e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s31415", + "operation": "stationary[80,81,82,83,84,85,86,87,88,89]", + "max_absolute_error": 1.3877787807814457e-17, + "max_relative_error": 2.0183346120152875e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s31415", + "operation": "stationary[90,91,92,93,94,95,96,97,98,99]", + "max_absolute_error": 1.1102230246251565e-16, + "max_relative_error": 2.2174142292479812e-16, + "passed": true + }, + { + "dataset": "reducible-n0100-s31415", + "operation": "occupation", + "max_absolute_error": 2.886579864025407e-15, + "max_relative_error": 4.042264149537729e-15, + "passed": true + } + ], + "skipped": [ + "absorbing-n0250-s01729", + "absorbing-n0250-s02718", + "absorbing-n0250-s31415", + "absorbing-n0500-s01729", + "absorbing-n0500-s02718", + "absorbing-n0500-s31415", + "absorbing-n1000-s01729", + "absorbing-n1000-s02718", + "absorbing-n1000-s31415", + "dense-n0250-s01729", + "dense-n0250-s02718", + "dense-n0250-s31415", + "dense-n0500-s01729", + "dense-n0500-s02718", + "dense-n0500-s31415", + "dense-n1000-s01729", + "dense-n1000-s02718", + "dense-n1000-s31415", + "low-outdegree-n0250-s01729", + "low-outdegree-n0250-s02718", + "low-outdegree-n0250-s31415", + "low-outdegree-n0500-s01729", + "low-outdegree-n0500-s02718", + "low-outdegree-n0500-s31415", + "low-outdegree-n1000-s01729", + "low-outdegree-n1000-s02718", + "low-outdegree-n1000-s31415", + "periodic-n0250-s01729", + "periodic-n0250-s02718", + "periodic-n0250-s31415", + "periodic-n0500-s01729", + "periodic-n0500-s02718", + "periodic-n0500-s31415", + "periodic-n1000-s01729", + "periodic-n1000-s02718", + "periodic-n1000-s31415", + "reducible-n0250-s01729", + "reducible-n0250-s02718", + "reducible-n0250-s31415", + "reducible-n0500-s01729", + "reducible-n0500-s02718", + "reducible-n0500-s31415", + "reducible-n1000-s01729", + "reducible-n1000-s02718", + "reducible-n1000-s31415" + ], + "passed": true +} diff --git a/benchmark/run.py b/benchmark/run.py new file mode 100644 --- /dev/null +++ b/benchmark/run.py @@ -0,0 +1,364 @@ +#!/usr/bin/env python3 +"""Reproducible orchestration for the dtmc versus PyDTMC benchmark.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import os +import platform +import subprocess +import sys +from pathlib import Path +from typing import Any + + +BENCHMARK_ROOT = Path(__file__).resolve().parent +PROJECT_ROOT = BENCHMARK_ROOT.parent +DATA_DIR = BENCHMARK_ROOT / "data" +DATA_ROOT = DATA_DIR / "generated" +RESULTS_ROOT = BENCHMARK_ROOT / "results" +VENV = BENCHMARK_ROOT / ".venv" +CABAL_PROJECT = "benchmark/cabal.project" +SPEC = json.loads((DATA_DIR / "spec.json").read_text(encoding="utf-8")) +SIZES = tuple(map(int, SPEC["sizes"])) +SEEDS = tuple(map(int, SPEC["seeds"])) +FAMILIES = tuple(map(str, SPEC["families"])) +THREAD_ENV = { + "OPENBLAS_NUM_THREADS": "1", + "OMP_NUM_THREADS": "1", + "MKL_NUM_THREADS": "1", + "VECLIB_MAXIMUM_THREADS": "1", + "NUMEXPR_NUM_THREADS": "1", + "MPLCONFIGDIR": str(BENCHMARK_ROOT / ".cache" / "matplotlib"), + "XDG_CACHE_HOME": str(BENCHMARK_ROOT / ".cache"), + "MPLBACKEND": "Agg", +} + + +def run(command: list[str], *, env: dict[str, str] | None = None) -> None: + printable = " ".join(command) + print(f"+ {printable}", flush=True) + subprocess.run(command, cwd=PROJECT_ROOT, env=env, check=True) + + +def capture(command: list[str], *, env: dict[str, str] | None = None) -> str: + try: + return subprocess.run( + command, + cwd=PROJECT_ROOT, + env=env, + check=True, + text=True, + stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, + ).stdout.strip() + except (OSError, subprocess.CalledProcessError) as problem: + return f"unavailable: {problem}" + + +def python_executable() -> Path: + name = "python.exe" if os.name == "nt" else "python" + return VENV / ("Scripts" if os.name == "nt" else "bin") / name + + +def haskell_executable() -> Path: + result = subprocess.run( + ["cabal", "list-bin", f"--project-file={CABAL_PROJECT}", "dtmc-bench"], + cwd=PROJECT_ROOT, + check=True, + text=True, + stdout=subprocess.PIPE, + ) + path = Path(result.stdout.strip()) + if not path.exists(): + raise RuntimeError("dtmc-bench is not built; run the bootstrap command first") + return path + + +def bootstrap() -> None: + (BENCHMARK_ROOT / ".cache" / "matplotlib").mkdir(parents=True, exist_ok=True) + if not python_executable().exists(): + run([sys.executable, "-m", "venv", str(VENV)]) + run( + [ + str(python_executable()), + "-m", + "pip", + "install", + "--disable-pip-version-check", + "-r", + str(BENCHMARK_ROOT / "python" / "requirements.lock"), + ] + ) + run(["cabal", "build", f"--project-file={CABAL_PROJECT}", "dtmc-bench"]) + + +def generate(mode: str) -> None: + sizes = SIZES if mode == "full" else (10,) + seeds = SEEDS if mode == "full" else (SEEDS[0],) + python = str(python_executable()) if python_executable().exists() else sys.executable + run( + [ + python, + str(DATA_DIR / "generate.py"), + "--sizes", + ",".join(map(str, sizes)), + "--seeds", + ",".join(map(str, seeds)), + ] + ) + + +def benchmark_environment( + entry: dict[str, Any], data_root: Path = DATA_ROOT +) -> dict[str, str]: + environment = os.environ.copy() + environment.update(THREAD_ENV) + environment.update( + { + "DTMC_BENCH_DATA": str(data_root), + "DTMC_BENCH_FAMILY": str(entry["family"]), + "DTMC_BENCH_SIZE": str(entry["size"]), + "DTMC_BENCH_SEED": str(entry["seed"]), + } + ) + return environment + + +def manifest_entries(mode: str, data_root: Path = DATA_ROOT) -> list[dict[str, Any]]: + manifest = json.loads((data_root / "manifest.json").read_text(encoding="utf-8")) + entries = list(manifest["datasets"]) + if mode == "smoke": + entries = [ + entry + for entry in entries + if entry["size"] == 10 and entry["seed"] == SEEDS[0] + ] + return entries + + +def verify(mode: str) -> None: + RESULTS_ROOT.mkdir(parents=True, exist_ok=True) + (BENCHMARK_ROOT / ".cache" / "matplotlib").mkdir(parents=True, exist_ok=True) + haskell_output = RESULTS_ROOT / "haskell-verification.json" + verification_output = RESULTS_ROOT / "verification.json" + environment = os.environ.copy() + environment.update(THREAD_ENV) + environment["DTMC_BENCH_DATA"] = str(DATA_ROOT) + environment["DTMC_VERIFY_MAX_SIZE"] = "100" if mode == "full" else "10" + run( + [ + str(haskell_executable()), + "--verify-json", + str(haskell_output), + ], + env=environment, + ) + run( + [ + str(python_executable()), + str(BENCHMARK_ROOT / "python" / "verify.py"), + str(haskell_output), + "--output", + str(verification_output), + ], + env=environment, + ) + + +def benchmark(mode: str) -> None: + raw_haskell = RESULTS_ROOT / "raw" / "haskell" + raw_python = RESULTS_ROOT / "raw" / "python" + raw_haskell.mkdir(parents=True, exist_ok=True) + raw_python.mkdir(parents=True, exist_ok=True) + + for entry in manifest_entries(mode): + name = str(entry["id"]) + environment = benchmark_environment(entry) + haskell_json = raw_haskell / f"{name}.json" + haskell_csv = raw_haskell / f"{name}.csv" + haskell_raw = raw_haskell / f"{name}.raw" + python_json = raw_python / f"{name}.json" + for output in (haskell_json, haskell_csv, haskell_raw, python_json): + output.unlink(missing_ok=True) + criterion_command = [ + str(haskell_executable()), + "--json", + str(haskell_json), + "--csv", + str(haskell_csv), + "--raw", + str(haskell_raw), + "--time-limit", + "0.1" if mode == "smoke" else "5", + "--resamples", + "100" if mode == "smoke" else "10000", + ] + run(criterion_command, env=environment) + + pyperf_command = [ + str(python_executable()), + str(BENCHMARK_ROOT / "python" / "bench.py"), + "--copy-env", + "-o", + str(python_json), + ] + if mode == "smoke": + pyperf_command.append("--fast") + run(pyperf_command, env=environment) + + +def record_environment( + results_root: Path = RESULTS_ROOT, + data_root: Path = DATA_ROOT, + benchmark_scope: list[str] | None = None, +) -> None: + results_root.mkdir(parents=True, exist_ok=True) + environment = os.environ.copy() + environment.update(THREAD_ENV) + python = str(python_executable()) if python_executable().exists() else sys.executable + haskell_binary = haskell_executable() + + def digest(path: Path) -> str: + return hashlib.sha256(path.read_bytes()).hexdigest() + + record = { + "captured_at_utc": capture(["date", "-u", "+%Y-%m-%dT%H:%M:%SZ"]), + "platform": platform.platform(), + "machine": platform.machine(), + "processor": platform.processor(), + "cpu_brand": capture(["sysctl", "-n", "machdep.cpu.brand_string"]), + "python": capture([python, "--version"]), + "python_packages": capture([python, "-m", "pip", "freeze"]), + "numpy_configuration": capture( + [python, "-c", "import numpy as n; n.show_config()"], env=environment + ), + "ghc": capture(["ghc", "--version"]), + "cabal": capture(["cabal", "--version"]), + "haskell_benchmark_binary": str(haskell_binary), + "haskell_benchmark_linkage": capture(["otool", "-L", str(haskell_binary)]), + "haskell_options": ["-O2", "-threaded", "-rtsopts"], + "cabal_freeze_sha256": digest(BENCHMARK_ROOT / "cabal.project.freeze"), + "python_lock_sha256": digest(BENCHMARK_ROOT / "python" / "requirements.lock"), + "dataset_spec_sha256": digest(DATA_DIR / "spec.json"), + "dataset_manifest_sha256": digest(data_root / "manifest.json"), + "git_commit": capture(["git", "rev-parse", "HEAD"]), + "git_status": capture(["git", "status", "--short"]), + "thread_environment": THREAD_ENV, + "benchmark_scope": benchmark_scope or "complete suite", + } + (results_root / "environment.json").write_text( + json.dumps(record, indent=2) + "\n", encoding="utf-8" + ) + + +def profile() -> None: + entries = manifest_entries("full") + candidates = [entry for entry in entries if entry["family"] == "dense"] + entry = next((item for item in candidates if item["size"] == 100), candidates[0]) + environment = benchmark_environment(entry) + profile_root = BENCHMARK_ROOT / "profiles" + profile_root.mkdir(parents=True, exist_ok=True) + for operation in ( + "stationary", + "hitting-probability/cold-all-states", + "race/forward-committor", + "return/mean-recurrence", + "visits/bounded-expectation/k-100", + "simulation/100000", + ): + safe = operation.replace("/", "-") + haskell_path = profile_root / f"haskell-{safe}.txt" + with haskell_path.open("w", encoding="utf-8") as stream: + subprocess.run( + [ + str(haskell_executable()), + "--time-limit", + "0.2", + "--resamples", + "100", + f"{entry['id']}/{operation}", + "+RTS", + "-s", + "-RTS", + ], + cwd=PROJECT_ROOT, + env=environment, + check=True, + stdout=stream, + stderr=subprocess.STDOUT, + ) + python_environment = environment.copy() + python_environment["DTMC_BENCH_OPERATION"] = operation + run( + [ + str(python_executable()), + str(BENCHMARK_ROOT / "python" / "bench.py"), + "--copy-env", + "--debug-single-value", + "--profile", + str(profile_root / f"python-{safe}.prof"), + ], + env=python_environment, + ) + + +def analyse( + results_root: Path = RESULTS_ROOT, data_root: Path = DATA_ROOT +) -> None: + run( + [ + str(python_executable()), + str(BENCHMARK_ROOT / "analyse.py"), + "--data-root", + str(data_root), + "--results-root", + str(results_root), + ] + ) + run( + [ + str(python_executable()), + str(BENCHMARK_ROOT / "plot.py"), + "--results-root", + str(results_root), + ] + ) + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument( + "command", + choices=( + "bootstrap", + "generate", + "verify", + "benchmark", + "profile", + "analyse", + "all", + ), + ) + parser.add_argument("--mode", choices=("smoke", "full"), default="smoke") + args = parser.parse_args() + + if args.command in {"bootstrap", "all"}: + bootstrap() + if args.command in {"generate", "all"}: + generate(args.mode) + if args.command in {"verify", "all"}: + verify(args.mode) + if args.command in {"benchmark", "all"}: + benchmark(args.mode) + if args.command == "profile": + profile() + if args.command in {"analyse", "all"}: + record_environment() + analyse() + + +if __name__ == "__main__": + main() diff --git a/cabal.project b/cabal.project new file mode 100644 --- /dev/null +++ b/cabal.project @@ -0,0 +1,7 @@ +packages: . + +-- Haddock includes private backend methods in public instance details. +-- Generate their internal documentation so those links have destinations; +-- this does not expose the module to library users. +program-options + haddock-options: --show=Dtmc.Transition.Internal diff --git a/dtmc.cabal b/dtmc.cabal --- a/dtmc.cabal +++ b/dtmc.cabal @@ -1,6 +1,6 @@ cabal-version: 3.0 name: dtmc -version: 0.2.0.0 +version: 0.3.0.0 synopsis: Type-safe discrete-time Markov chains description: Type-safe finite discrete-time Markov chains with matrix and kernel @@ -16,7 +16,7 @@ license: BSD-3-Clause license-file: LICENSE author: Arkadii Kholmetskii -maintainer: Arkadii Kholmetskii <373321aa@gmail.com> +maintainer: Arkadii Kholmetskii copyright: 2026 Arkadii Kholmetskii build-type: Simple tested-with: @@ -29,6 +29,32 @@ README.md CHANGELOG.md +extra-source-files: + cabal.project + benchmark/README.md + benchmark/REPORT.md + benchmark/results/environment.json + benchmark/results/ratio-summary.csv + benchmark/results/ratios.csv + benchmark/results/scaling.csv + benchmark/results/summary.csv + benchmark/results/verification.json + benchmark/results/plots/absorbing--hitting-bounded-exact-k-100--speed-ratio.svg + benchmark/results/plots/dense--evolution-one-step--speed-ratio.svg + benchmark/results/plots/dense--hitting-time-cold-all-states--speed-ratio.svg + benchmark/results/plots/periodic--finite-time-observation-k-100--speed-ratio.svg + benchmark/cabal.project + benchmark/cabal.project.freeze + benchmark/analyse.py + benchmark/plot.py + benchmark/run.py + benchmark/data/generate.py + benchmark/data/spec.json + benchmark/python/bench.py + benchmark/python/pyproject.toml + benchmark/python/requirements.lock + benchmark/python/verify.py + common lang default-language: GHC2021 @@ -74,10 +100,13 @@ other-modules: Dtmc.Distribution.Vector.Internal Dtmc.Distribution.Map.Internal + Dtmc.Transition.Internal Dtmc.Transition.Matrix.Internal Dtmc.Simplex.Internal + Dtmc.Analysis.FiniteHorizon.Internal Dtmc.Analysis.FiniteTime.Internal Dtmc.Analysis.Classification.Internal + Dtmc.Analysis.Classification.Reachability.Internal Dtmc.Analysis.LinearSystem.Internal Dtmc.Analysis.Initial.Internal Dtmc.Transition.Matrix.Internal.Graph @@ -92,6 +121,7 @@ , hmatrix >=0.20.2 && <0.21 , mwc-random >=0.15.0.1 && <0.16 , primitive >=0.9 && <0.10 + , vector >=0.13 && <0.14 test-suite spec import: lang @@ -141,6 +171,35 @@ build-tool-depends: hspec-discover:hspec-discover >=2.11.17 && <2.12 +benchmark dtmc-bench + import: lang + type: exitcode-stdio-1.0 + hs-source-dirs: benchmark/haskell + main-is: Main.hs + + other-modules: + Cases + Dataset + Force + Verification + + ghc-options: + -threaded + -rtsopts + + build-depends: + aeson >=2.2 && <2.3 + , base + , binary >=0.8.9 && <0.9 + , bytestring >=0.11 && <0.13 + , criterion >=1.6.4 && <1.7 + , deepseq >=1.4.8 && <1.6 + , dtmc + , finite-typelits + , filepath >=1.4 && <1.6 + , mwc-random + , vector >=0.13 && <0.14 + source-repository head type: git location: https://github.com/kholmetskii/dtmc.git @@ -148,4 +207,4 @@ source-repository this type: git location: https://github.com/kholmetskii/dtmc.git - tag: v0.2.0.0 + tag: v0.3.0.0 diff --git a/src/Dtmc/Analysis/Absorption.hs b/src/Dtmc/Analysis/Absorption.hs --- a/src/Dtmc/Analysis/Absorption.hs +++ b/src/Dtmc/Analysis/Absorption.hs @@ -42,6 +42,7 @@ fundamentalMatrix, -- * Absorption probabilities + probabilityMatrix, probability, probabilityGivenInitialState, @@ -69,6 +70,8 @@ ) import Dtmc.Analysis.LinearSystem.Internal ( fundamental, + solveIminusQ, + solveIminusQVector, subMatrix, ) import Dtmc.Distribution ( @@ -103,7 +106,6 @@ retains @O(n + E)@ graph-cache space. -} canonicalOrder :: - (FiniteState state) => TransitionMatrix state -> ([state], [state]) canonicalOrder p = @@ -142,6 +144,42 @@ transientIdx = map toIndex transient matrix = unTransitionMatrix p +{- | Compute the complete transient-to-recurrent absorption-probability matrix +@B = (I - Q)^-1 R'@. + +The returned triple contains the transient row states, the recurrent column +states, and the matrix rows in those respective canonical orders. Entry +@(i,k)@ is the probability that recurrent state @k@ is the first recurrent +state visited when starting from transient state @i@. + +All recurrent columns are solved together, sharing one factorisation of +@I - Q@. A chain with no transient states returns empty matrix rows without a +solve. + +Complexity: including first-time graph classification, +@O(n^2 + (n + E) log(n + 1) + t^3 + t^2 r)@ time, +@O(n^2 + n + E + t^2 + t r)@ temporary space, @O(n + E)@ retained +graph-cache space, and @O(t r)@ result space for @r@ recurrent states. +-} +probabilityMatrix :: + (FiniteState state) => + TransitionMatrix state -> + Either LinearSystemError ([state], [state], [[Double]]) +probabilityMatrix p + | null transient = Right ([], recurrent, []) + | otherwise = do + values <- + solveIminusQ + (subMatrix transientIdx transientIdx matrix) + (subMatrix transientIdx recurrentIdx matrix) + pure (transient, recurrent, LA.toLists values) + where + transient = transientStates p + recurrent = recurrentStates p + transientIdx = map toIndex transient + recurrentIdx = map toIndex recurrent + matrix = unTransitionMatrix p + {- | Compute absorption probabilities into one recurrent state in canonical state order. Coordinate @i@ is the probability that the supplied target is the first recurrent state visited when starting from @i@. @@ -152,8 +190,8 @@ * a recurrent starting state has already arrived, so its coordinate is @1@ when it is the target and @0@ otherwise. -Transient coordinates are the corresponding column of @B = G R'@ and inherit -the numerical behaviour and errors of 'fundamentalMatrix'. +Transient coordinates solve @(I - Q) b = R'(:,k)@ directly and inherit the +numerical behaviour and errors of the shared linear solver. Complexity: including first-time graph classification, @O(n^2 + (n + E) log(n + 1) + t^3)@ worst-case time, @@ -173,9 +211,12 @@ | null transientIdx = Right (LA.fromList [arrived i | i <- [0 .. dim - 1]]) | otherwise = do - g <- fundamental (subMatrix transientIdx transientIdx matrix) let exits = LA.flatten (subMatrix transientIdx [targetIdx] matrix) - solved = LA.toList (g LA.#> exits) + transientProbabilities <- + solveIminusQVector + (subMatrix transientIdx transientIdx matrix) + exits + let solved = LA.toList transientProbabilities interior :: Unboxed.UArray Int Double interior = Unboxed.accumArray @@ -226,8 +267,10 @@ state visited, conditioned on @X_0 = i@. A recurrent initial state is already absorbed at time zero. -Partial application shares one lazy all-state table. A non-recurrent target -produces exact zeros without a numerical solve. +Partial application shares one lazy all-state table for transient starting +states. Recurrent starting states return their exact boundary values without +forcing that table. A non-recurrent target produces exact zeros without a +numerical solve. Complexity: the first forced query takes @O(n^3)@ worst-case time and @O(n^2)@ temporary space and may retain an @O(n)@ all-state result and @@ -241,8 +284,14 @@ state -> Either LinearSystemError Double probabilityGivenInitialState p target = - \i -> (`LA.atIndex` toIndex i) <$> values + atInitial where + atInitial initial + | not targetIsRecurrent = Right 0 + | recurrentState p initial = + Right (if initial == target then 1 else 0) + | otherwise = (`LA.atIndex` toIndex initial) <$> values + targetIsRecurrent = recurrentState p target values = probabilityByState p target {- | Compute the expected number of transitions until the chain first enters diff --git a/src/Dtmc/Analysis/Classification.hs b/src/Dtmc/Analysis/Classification.hs --- a/src/Dtmc/Analysis/Classification.hs +++ b/src/Dtmc/Analysis/Classification.hs @@ -17,7 +17,8 @@ 'FiniteState' method costs and construction of the shared support graph. Its first use adds @O(n^2)@ time and temporary space and retains @O(n + E)@ cache space. Strong components, closedness, periods, and phases are also computed -lazily and shared by later queries on the same matrix. +lazily. The complete typed classification is retained after first use, so +whole-chain queries share public classes and state lists as well as the graph. A @0 x 0@ matrix has no communicating classes and is neither irreducible nor aperiodic here. @@ -66,7 +67,11 @@ stateFromInt, stateIndexInt, ) -import Dtmc.Transition.Matrix.Internal (TransitionMatrix, tmSupport) +import Dtmc.Transition.Matrix.Internal ( + TransitionMatrix, + tmClassification, + tmSupport, + ) import Dtmc.Transition.Matrix.Internal.Graph qualified as G import Numeric.Natural (Natural) @@ -152,11 +157,11 @@ Complexity: excluding shared support-graph construction, the first full evaluation takes @O(n + E + n log(n + 1))@ time and @O(n + E)@ temporary -space and retains @O(n)@ component cache; subsequent evaluations take -@O(n)@ time and temporary space. Result space is @O(n)@. +space and retains @O(n)@ classification space. Subsequent calls take @O(1)@ +time and space before traversal of the shared result; traversing every member +still takes @O(n)@ time. The @O(n)@ result is retained by the matrix. -} communicatingClasses :: - (FiniteState state) => TransitionMatrix state -> [CommClass state] communicatingClasses = classesOf . classify @@ -284,10 +289,10 @@ Complexity: excluding shared support-graph construction, the first full evaluation takes @O((n + E) log(n + 1))@ time and @O(n + E)@ temporary space -and retains @O(n)@ component and closedness cache; later evaluations take -@O(n)@ time and temporary space. Result space is @O(n)@. +and retains @O(n)@ graph and classification space. Later calls take @O(1)@ +time and space before traversal of the shared @O(n)@ result. -} -recurrentStates :: (FiniteState state) => TransitionMatrix state -> [state] +recurrentStates :: TransitionMatrix state -> [state] recurrentStates = recurrentStatesOf . classify {- | Return the members of non-closed communicating classes, ordered by class @@ -297,10 +302,10 @@ Complexity: excluding shared support-graph construction, the first full evaluation takes @O((n + E) log(n + 1))@ time and @O(n + E)@ temporary space -and retains @O(n)@ component and closedness cache; later evaluations take -@O(n)@ time and temporary space. Result space is @O(n)@. +and retains @O(n)@ graph and classification space. Later calls take @O(1)@ +time and space before traversal of the shared @O(n)@ result. -} -transientStates :: (FiniteState state) => TransitionMatrix state -> [state] +transientStates :: TransitionMatrix state -> [state] transientStates = transientStatesOf . classify {- | Return the states that form a communicating class on their own and cannot @@ -312,10 +317,10 @@ Complexity: excluding shared support-graph construction, the first full evaluation takes @O((n + E) log(n + 1))@ time and @O(n + E)@ temporary space -and retains @O(n)@ component and closedness cache; later evaluations take -@O(n)@ time and temporary space. Result space is @O(n)@. +and retains @O(n)@ graph and classification space. Later calls take @O(1)@ +time and space before traversal of the shared result. -} -absorbingStates :: (FiniteState state) => TransitionMatrix state -> [state] +absorbingStates :: TransitionMatrix state -> [state] absorbingStates = absorbingStatesOf . classify {- | Return the period shared by every state of an irreducible chain. Returns @@ -330,7 +335,7 @@ component and period cache; later queries take @O(1)@ time. Temporary and result space per cached query are @O(1)@. -} -chainPeriod :: (FiniteState state) => TransitionMatrix state -> Maybe Natural +chainPeriod :: TransitionMatrix state -> Maybe Natural chainPeriod = chainPeriodOf . classify {- | Test whether the chain is irreducible and aperiodic. For a finite DTMC @@ -351,34 +356,8 @@ Complexity: full evaluation on an unforced matrix takes @O(n^2 + (n + E) log(n + 1))@ time, @O(n^2 + n + E)@ temporary space, -@O(n + E)@ retained graph-cache space, and @O(n)@ result space. With all -graph facts cached, it takes @O(n)@ time and @O(n)@ temporary and result -space. +and @O(n + E)@ retained graph and classification space. Later calls take +@O(1)@ time and space before traversal of the shared result. -} -classify :: (FiniteState state) => TransitionMatrix state -> Classification state -classify p = - Classification - { classesOf = cs - , isIrreducible = irreducible' - , isAperiodic = aperiodic' - , isErgodic = irreducible' && aperiodic' - , chainPeriodOf = chainPeriodOf' - , recurrentStatesOf = concatMap classMembers (filter classClosed cs) - , transientStatesOf = concatMap classMembers (filter (not . classClosed) cs) - , absorbingStatesOf = [i | cc <- cs, classClosed cc, [i] <- [classMembers cc]] - } - where - g = tmSupport p - cs = - [ CommClass - { classMembers = map toState c - , classPeriod = G.periodOf g v - , classClosed = G.inClosedComponent g v - } - | c@(v : _) <- G.components g - ] - irreducible' = graphIrreducible g - aperiodic' = graphAperiodic g - chainPeriodOf' = case cs of - [c] -> classPeriod c - _ -> Nothing +classify :: TransitionMatrix state -> Classification state +classify = tmClassification diff --git a/src/Dtmc/Analysis/Classification/Internal.hs b/src/Dtmc/Analysis/Classification/Internal.hs --- a/src/Dtmc/Analysis/Classification/Internal.hs +++ b/src/Dtmc/Analysis/Classification/Internal.hs @@ -2,34 +2,18 @@ {- | Module : Dtmc.Analysis.Classification.Internal -Description : Internal carriers and graph operations for chain classification. +Description : Internal carriers and construction for chain classification. -Raw carrier types and solver-oriented graph operations behind -"Dtmc.Analysis.Classification": the per-class summary t'CommClass' and the -whole-chain structural report t'Classification'. This module exposes the -report constructor for trusted internal use; constructing it here may produce -summary fields inconsistent with its communicating classes. +Raw carrier types behind "Dtmc.Analysis.Classification": the per-class summary +@CommClass@ and whole-chain structural report @Classification@. The report +builder is shared with the transition-matrix cache. -} module Dtmc.Analysis.Classification.Internal ( type CommClass (..), type Classification (..), - backwardReachable, + classificationFromGraph, ) where -import Data.Maybe ( - fromMaybe, - ) -import Dtmc.State ( - FiniteState, - ) -import Dtmc.State.Internal ( - stateFromInt, - stateIndexInt, - ) -import Dtmc.Transition.Matrix.Internal ( - TransitionMatrix, - tmSupport, - ) import Dtmc.Transition.Matrix.Internal.Graph qualified as G import Numeric.Natural ( Natural, @@ -89,32 +73,52 @@ deriving instance (Show state) => Show (Classification state) -toState :: (FiniteState state) => Int -> state -toState index = - fromMaybe - (error "Dtmc.Analysis.Classification.Internal: graph vertex out of bounds") - (stateFromInt index) - -toIndex :: (FiniteState state) => state -> Int -toIndex = stateIndexInt - -{- | Return states from which an allowed seed is reachable along a support -path containing only states accepted by @allowed@. Disallowed seeds are -ignored; the result is duplicate-free and ordered by state index. +{- | Build a complete typed classification from an index-to-state conversion +and a shared support graph. Supplying the canonical conversion of a +'Dtmc.State.FiniteState' instance produces the public classification. -For the complexity bounds, @n@ is the state count, @E@ the support-edge count, -@s@ the number of supplied seeds, and @r@ the number of returned states. +The result is deliberately lazy so a transition matrix can carry it without +forcing graph construction. Once forced, all whole-chain projections share +the same classes and state lists. -Complexity: excluding @n@ evaluations of @allowed@, 'FiniteState' method -costs, and shared support-graph construction, @O(n + E + s)@ time, -@O(n + E + s)@ temporary space, and @O(r)@ result space. The first reverse -traversal also retains @O(n + E)@ predecessor-cache space. +Complexity: @O(n + E)@ time after the graph's component and period caches are +available, @O(n)@ temporary space, and @O(n)@ retained result space. -} -backwardReachable :: - (FiniteState state) => - TransitionMatrix state -> - (state -> Bool) -> - [state] -> - [state] -backwardReachable p allowed seeds = - map toState (G.backwardReachable (tmSupport p) (allowed . toState) (map toIndex seeds)) +classificationFromGraph :: (Int -> state) -> G.Graph -> Classification state +classificationFromGraph toState graph = + Classification + { classesOf = communicating + , isIrreducible = irreducible' + , isAperiodic = aperiodic' + , isErgodic = irreducible' && aperiodic' + , chainPeriodOf = case communicating of + [communicatingClass] -> classPeriod communicatingClass + _ -> Nothing + , recurrentStatesOf = + concatMap classMembers (filter classClosed communicating) + , transientStatesOf = + concatMap classMembers (filter (not . classClosed) communicating) + , absorbingStatesOf = + [ state + | communicatingClass <- communicating + , classClosed communicatingClass + , [state] <- [classMembers communicatingClass] + ] + } + where + components = G.components graph + communicating = + [ CommClass + { classMembers = map toState component + , classPeriod = G.periodOf graph first + , classClosed = G.inClosedComponent graph first + } + | component@(first : _) <- components + ] + irreducible' = case components of + [component] -> not (null component) + _ -> False + aperiodic' = + not (null components) + && all ((== Just 1) . G.componentPeriod graph) components +{-# INLINE classificationFromGraph #-} diff --git a/src/Dtmc/Analysis/Classification/Reachability/Internal.hs b/src/Dtmc/Analysis/Classification/Reachability/Internal.hs new file mode 100644 --- /dev/null +++ b/src/Dtmc/Analysis/Classification/Reachability/Internal.hs @@ -0,0 +1,47 @@ +{- | +Module : Dtmc.Analysis.Classification.Reachability.Internal +Description : Solver-oriented typed support-graph reachability. + +Internal adapter between finite-state values and the integer support graph. +-} +module Dtmc.Analysis.Classification.Reachability.Internal ( + backwardReachable, +) where + +import Data.Maybe (fromMaybe) +import Dtmc.State (FiniteState) +import Dtmc.State.Internal (stateFromInt, stateIndexInt) +import Dtmc.Transition.Matrix.Internal (TransitionMatrix, tmSupport) +import Dtmc.Transition.Matrix.Internal.Graph qualified as G + +toState :: (FiniteState state) => Int -> state +toState index = + fromMaybe + (error "Dtmc.Analysis.Classification: graph vertex out of bounds") + (stateFromInt index) + +{- | Return states from which an allowed seed is reachable along a support +path containing only states accepted by @allowed@. Disallowed seeds are +ignored; the result is duplicate-free and ordered by state index. + +For the complexity bounds, @n@ is the state count, @E@ the support-edge count, +@s@ the number of supplied seeds, and @r@ the number of returned states. + +Complexity: excluding @n@ evaluations of @allowed@, 'FiniteState' method +costs, and shared support-graph construction, @O(n + E + s)@ time, +@O(n + E + s)@ temporary space, and @O(r)@ result space. The first reverse +traversal also retains @O(n + E)@ predecessor-cache space. +-} +backwardReachable :: + (FiniteState state) => + TransitionMatrix state -> + (state -> Bool) -> + [state] -> + [state] +backwardReachable matrix allowed seeds = + map toState + ( G.backwardReachable + (tmSupport matrix) + (allowed . toState) + (map stateIndexInt seeds) + ) diff --git a/src/Dtmc/Analysis/FiniteHorizon/Internal.hs b/src/Dtmc/Analysis/FiniteHorizon/Internal.hs new file mode 100644 --- /dev/null +++ b/src/Dtmc/Analysis/FiniteHorizon/Internal.hs @@ -0,0 +1,296 @@ +{-# LANGUAGE TypeFamilies #-} + +{- | +Module : Dtmc.Analysis.FiniteHorizon.Internal +Description : Dense finite-state primitives for finite-horizon analyses. + +Private BLAS-backed recurrences shared by finite-time, hitting-time, +return-time, and bounded-visit analyses. Public analysis modules retain their +locally finite map recurrences and select these implementations only when a +transition representation supplies a suitable dense backend. +-} +module Dtmc.Analysis.FiniteHorizon.Internal ( + availableDenseBackend, + branchingDenseBackend, + denseStepProbability, + denseProbabilityAfter, + denseExactHittingProbability, + denseLowerHittingProbability, + denseUpperHittingProbability, + denseExactReturnProbability, + denseLowerReturnProbability, + denseUpperReturnProbability, + denseBoundedVisitExpectation, +) where + +import Data.Map.Strict qualified as Map +import Data.Vector.Storable qualified as Storable +import Data.Vector.Storable.Mutable qualified as Mutable +import Dtmc.Transition.Internal ( + DenseTransitionBackend (..), + Transition (..), + denseRowBranches, + ) +import Numeric.LinearAlgebra qualified as LA +import Numeric.Natural ( + Natural, + ) + +availableDenseBackend :: + (Transition transition) => + transition -> + Maybe (DenseTransitionBackend (TransitionState transition)) +availableDenseBackend = transitionDenseBackend + +branchingDenseBackend :: + (Transition transition) => + transition -> + [TransitionState transition] -> + Maybe (DenseTransitionBackend (TransitionState transition)) +branchingDenseBackend transition sources = do + backend <- availableDenseBackend transition + if any (denseRowBranches backend) sources then Just backend else Nothing + +denseStepProbability :: + DenseTransitionBackend state -> + state -> + state -> + Double +denseStepProbability backend source destination = + denseTransitionMatrix backend + `LA.atIndex` ( denseTransitionIndex backend source + , denseTransitionIndex backend destination + ) + +denseProbabilityAfter :: + Natural -> + [(state, Double)] -> + DenseTransitionBackend state -> + state -> + Double +denseProbabilityAfter steps weights backend destination = + evolved Storable.! denseTransitionIndex backend destination + where + evolved = iterateDense steps backend (weightsVector backend weights) + +denseExactHittingProbability :: + Natural -> + DenseTransitionBackend state -> + (state -> Bool) -> + state -> + Double +denseExactHittingProbability time backend isTarget initial = + go time (pointVector backend initial) + where + targets = denseTargetSet backend initial isTarget + + go 0 _ = 0 + go remaining survivors = + let advanced = advanceDense backend survivors + hitMass = targetMass targets advanced + in if remaining == 1 + then hitMass + else + let next = clearTargets targets advanced + in next `seq` + if Storable.all (== 0) next + then 0 + else go (remaining - 1) next + +denseLowerHittingProbability :: + Natural -> + DenseTransitionBackend state -> + (state -> Bool) -> + state -> + Double +denseLowerHittingProbability steps backend isTarget initial = + go steps (pointVector backend initial) 0 + where + targets = denseTargetSet backend initial isTarget + + go 0 _ total = total + go remaining survivors total = + let advanced = advanceDense backend survivors + hitMass = targetMass targets advanced + cumulative = total + hitMass + next = clearTargets targets advanced + in cumulative `seq` + next `seq` + if Storable.all (== 0) next + then cumulative + else go (remaining - 1) next cumulative + +denseUpperHittingProbability :: + Natural -> + DenseTransitionBackend state -> + (state -> Bool) -> + state -> + Double +denseUpperHittingProbability time backend isTarget initial = + go time (pointVector backend initial) + where + targets = denseTargetSet backend initial isTarget + + go 0 survivors = Storable.sum survivors + go remaining survivors = + let advanced = advanceDense backend survivors + next = clearTargets targets advanced + in next `seq` + if Storable.all (== 0) next + then 0 + else go (remaining - 1) next + +denseExactReturnProbability :: + Natural -> + DenseTransitionBackend state -> + state -> + Double +denseExactReturnProbability time backend initial = + go time (pointVector backend initial) + where + initialIndex = denseTransitionIndex backend initial + + go 0 _ = 0 + go remaining survivors = + let advanced = advanceDense backend survivors + returnMass = advanced Storable.! initialIndex + in if remaining == 1 + then returnMass + else go (remaining - 1) (clearCoordinate initialIndex advanced) + +denseLowerReturnProbability :: + Natural -> + DenseTransitionBackend state -> + state -> + Double +denseLowerReturnProbability bound backend initial = + go bound (pointVector backend initial) 0 + where + initialIndex = denseTransitionIndex backend initial + + go remaining _ total | remaining <= 1 = total + go remaining survivors total = + let advanced = advanceDense backend survivors + returnMass = advanced Storable.! initialIndex + cumulative = total + returnMass + next = clearCoordinate initialIndex advanced + in cumulative `seq` next `seq` go (remaining - 1) next cumulative + +denseUpperReturnProbability :: + Natural -> + DenseTransitionBackend state -> + state -> + Double +denseUpperReturnProbability time backend initial = + go time (pointVector backend initial) + where + initialIndex = denseTransitionIndex backend initial + + go 0 survivors = Storable.sum survivors + go remaining survivors = + let advanced = advanceDense backend survivors + next = clearCoordinate initialIndex advanced + in next `seq` go (remaining - 1) next + +denseBoundedVisitExpectation :: + Natural -> + Map.Map state Double -> + DenseTransitionBackend state -> + (state -> Bool) -> + Double +denseBoundedVisitExpectation 0 _ _ _ = 0 +denseBoundedVisitExpectation bound weights backend isVisited = + go bound (weightsVector backend (Map.toList weights)) 0 + where + visitedMask = + Storable.fromList + [if isVisited state then 1 else 0 | state <- denseTransitionStates backend] + + go remaining current expectation = + let visitProbability = visitedMask LA.<.> current + cumulative = expectation + visitProbability + in if remaining == 1 + then cumulative + else + let next = advanceDense backend current + in cumulative `seq` next `seq` go (remaining - 1) next cumulative + +advanceDense :: + DenseTransitionBackend state -> + LA.Vector Double -> + LA.Vector Double +advanceDense backend = (LA.tr (denseTransitionMatrix backend) LA.#>) + +iterateDense :: + Natural -> + DenseTransitionBackend state -> + LA.Vector Double -> + LA.Vector Double +iterateDense 0 _ weights = weights +iterateDense remaining backend weights = + let next = advanceDense backend weights + in next `seq` iterateDense (remaining - 1) backend next + +pointVector :: DenseTransitionBackend state -> state -> LA.Vector Double +pointVector backend selected = + Storable.generate dimension $ \index -> + if index == selectedIndex then 1 else 0 + where + dimension = LA.rows (denseTransitionMatrix backend) + selectedIndex = denseTransitionIndex backend selected + +weightsVector :: + DenseTransitionBackend state -> + [(state, Double)] -> + LA.Vector Double +weightsVector backend weights = + Storable.accum + (+) + (Storable.replicate dimension 0) + [ (denseTransitionIndex backend state, weight) + | (state, weight) <- weights + , weight /= 0 + ] + where + dimension = LA.rows (denseTransitionMatrix backend) + +-- Target coordinates in dense-backend order. Keeping only matching indices +-- avoids full floating-point target and survivor masks. +newtype DenseTargetSet = DenseTargetSet + { denseTargetIndices :: Storable.Vector Int + } + +denseTargetSet :: + DenseTransitionBackend state -> + state -> + (state -> Bool) -> + DenseTargetSet +denseTargetSet backend initial isTarget = + DenseTargetSet + ( Storable.fromList + [ index + | (index, state) <- zip [0 ..] (denseTransitionStates backend) + , index /= initialIndex + , isTarget state + ] + ) + where + initialIndex = denseTransitionIndex backend initial + +targetMass :: DenseTargetSet -> LA.Vector Double -> Double +targetMass targets values = + Storable.foldl' + (\total index -> total + Storable.unsafeIndex values index) + 0 + (denseTargetIndices targets) + +clearTargets :: DenseTargetSet -> LA.Vector Double -> LA.Vector Double +clearTargets targets = + Storable.modify $ \mutable -> + Storable.forM_ + (denseTargetIndices targets) + (\index -> Mutable.unsafeWrite mutable index 0) + +clearCoordinate :: Int -> LA.Vector Double -> LA.Vector Double +clearCoordinate index = + Storable.modify $ \mutable -> Mutable.unsafeWrite mutable index 0 diff --git a/src/Dtmc/Analysis/FiniteTime.hs b/src/Dtmc/Analysis/FiniteTime.hs --- a/src/Dtmc/Analysis/FiniteTime.hs +++ b/src/Dtmc/Analysis/FiniteTime.hs @@ -17,6 +17,15 @@ ConditionalProbabilityError (..), ) where +import Data.Maybe ( + fromMaybe, + ) +import Dtmc.Analysis.FiniteHorizon.Internal ( + availableDenseBackend, + branchingDenseBackend, + denseProbabilityAfter, + denseStepProbability, + ) import Dtmc.Analysis.FiniteTime.Internal ( NormalisedObservations (..), normalise, @@ -41,7 +50,8 @@ observations denotes their conjunction; list order has no meaning. -} data Observation state - = At Natural state -- ^ Require the supplied state at the specified time. + = -- | Require the supplied state at the specified time. + At Natural state deriving (Eq, Show) -- | Why a conditional probability query has no defined value. @@ -53,8 +63,10 @@ {- | Return the one-step transition probability @P(X_1 = j | X_0 = i)@ through any locally finite 'Transition'. -Complexity: excluding 'transitionLaw', @O(log(s + 1))@ time and @O(1)@ -temporary and result space for returned law support size @s@. +For a transition matrix, the dense backend reads the matrix entry directly in +@O(1)@ time and space. Otherwise, excluding 'transitionLaw', complexity is +@O(log(s + 1))@ time and @O(1)@ temporary and result space for returned law +support size @s@. -} stepProbability :: (Transition kernel, Ord (TransitionState kernel)) => @@ -62,8 +74,14 @@ TransitionState kernel -> TransitionState kernel -> Double -stepProbability kernel source = - probabilityAt (transitionLaw kernel source) +stepProbability kernel source destination = + fromMaybe genericProbability optimizedProbability + where + optimizedProbability = do + backend <- availableDenseBackend kernel + pure (denseStepProbability backend source destination) + genericProbability = + probabilityAt (transitionLaw kernel source) destination {- | Return the @k@-step transition probability @P(X_k = j | X_0 = i)@. At @k = 0@ this is the Kronecker delta. @@ -75,6 +93,9 @@ Complexity: excluding 'transitionLaw', @O(k (w + e log(u + 1) + u) + log(r + 1) + 1)@ time, @O(w + u)@ temporary space, and @O(1)@ result space. + +For a transition matrix whose source row branches, the adaptive dense path +takes @O(k n^2 + n)@ time and @O(n)@ temporary space for @n@ states. -} nStepProbability :: (Transition kernel, Ord (TransitionState kernel)) => @@ -83,8 +104,18 @@ TransitionState kernel -> TransitionState kernel -> Double -nStepProbability steps kernel source = - probabilityAt (evolveN steps (pointMass source) kernel) +nStepProbability 0 _ source destination = + if source == destination then 1 else 0 +nStepProbability 1 kernel source destination = + stepProbability kernel source destination +nStepProbability steps kernel source destination = + fromMaybe genericProbability optimizedProbability + where + optimizedProbability = do + backend <- branchingDenseBackend kernel [source] + pure (denseProbabilityAfter steps [(source, 1)] backend destination) + genericProbability = + probabilityAt (evolveN steps (pointMass source) kernel) destination {- | Compute the probability of a conjunction of timed observations. Observation order has no meaning, duplicates collapse, and an empty @@ -105,6 +136,10 @@ 'transitionLaw' evaluations, @O(m log(m + 1) + s_0 + k C + q log(r + 1) + 1)@ time, @O(m + w + u)@ temporary space, and @O(1)@ result space. + +When the initial support contains a branching transition-matrix row, the +first observation uses dense propagation; later gaps use the same adaptive +matrix path described by 'nStepProbability'. -} probability :: ( Distribution distribution @@ -121,9 +156,20 @@ Impossible -> 0 Consistent [] -> 1 Consistent ((firstTime, firstState) : rest) -> - probabilityAt (evolveN firstTime initial kernel) firstState + firstProbability firstTime firstState * gaps (firstTime, firstState) rest where + firstProbability firstTime firstState + | firstTime == 0 = genericProbability + | otherwise = fromMaybe genericProbability optimizedProbability + where + weights = distributionWeights initial + optimizedProbability = do + backend <- branchingDenseBackend kernel (map fst weights) + pure (denseProbabilityAfter firstTime weights backend firstState) + genericProbability = + probabilityAt (evolveN firstTime initial kernel) firstState + gaps _ [] = 1 gaps (previousTime, previousState) ((time, state) : more) = nStepProbability diff --git a/src/Dtmc/Analysis/HittingTime.hs b/src/Dtmc/Analysis/HittingTime.hs --- a/src/Dtmc/Analysis/HittingTime.hs +++ b/src/Dtmc/Analysis/HittingTime.hs @@ -50,7 +50,7 @@ import Data.Maybe ( fromMaybe, ) -import Dtmc.Analysis.Classification.Internal ( +import Dtmc.Analysis.Classification.Reachability.Internal ( backwardReachable, ) import Dtmc.Analysis.Event ( @@ -59,6 +59,12 @@ import Dtmc.Analysis.Expectation ( Expectation (..), ) +import Dtmc.Analysis.FiniteHorizon.Internal ( + branchingDenseBackend, + denseExactHittingProbability, + denseLowerHittingProbability, + denseUpperHittingProbability, + ) import Dtmc.Analysis.Initial.Internal ( expectationUnderEither, probabilityUnder, @@ -147,8 +153,13 @@ exactProbabilityAt time kernel isTarget initialState | time == 0 = if isTarget initialState then 1 else 0 | isTarget initialState = 0 - | otherwise = go time (Map.singleton initialState 1) + | otherwise = fromMaybe genericProbability optimizedProbability where + optimizedProbability = do + backend <- branchingDenseBackend kernel [initialState] + pure (denseExactHittingProbability time backend isTarget initialState) + genericProbability = go time (Map.singleton initialState 1) + go 0 _ = 0 go _ survivors | Map.null survivors = 0 go remaining survivors = @@ -178,8 +189,19 @@ lowerTailProbability bound kernel isTarget initialState | bound == 0 = 0 | isTarget initialState = 1 - | otherwise = go (bound - 1) (Map.singleton initialState 1) 0 + | otherwise = fromMaybe genericProbability optimizedProbability where + optimizedProbability = do + backend <- branchingDenseBackend kernel [initialState] + pure + ( denseLowerHittingProbability + (bound - 1) + backend + isTarget + initialState + ) + genericProbability = go (bound - 1) (Map.singleton initialState 1) 0 + go 0 _ total = total go _ survivors total | Map.null survivors = total go remaining survivors total = @@ -469,8 +491,14 @@ Double upperTailProbability time kernel isTarget initialState | isTarget initialState = 0 - | otherwise = go time (Map.singleton initialState 1) + | time == 0 = 1 + | otherwise = fromMaybe genericProbability optimizedProbability where + optimizedProbability = do + backend <- branchingDenseBackend kernel [initialState] + pure (denseUpperHittingProbability time backend isTarget initialState) + genericProbability = go time (Map.singleton initialState 1) + go 0 survivors = sum (Map.elems survivors) go _ survivors | Map.null survivors = 0 go remaining survivors = @@ -524,6 +552,10 @@ Complexity: excluding 'transitionLaw' and predicate evaluation, @O(k (w + e log(u + 1) + u) + 1)@ time, @O(w + u)@ temporary space, and @O(1)@ result space. + +For a transition matrix whose initial row branches, the adaptive dense path +evaluates the target predicate once per finite state and takes +@O(n + k n^2)@ time and @O(n)@ temporary space for @n@ states. -} probabilityGivenInitialState :: ( Transition kernel diff --git a/src/Dtmc/Analysis/Limiting.hs b/src/Dtmc/Analysis/Limiting.hs --- a/src/Dtmc/Analysis/Limiting.hs +++ b/src/Dtmc/Analysis/Limiting.hs @@ -91,7 +91,7 @@ retains @O(n + E)@ graph and classification caches. With those facts cached, it takes @O(c)@ time, @O(c)@ temporary space, and @O(1)@ result space. -} -converges :: (FiniteState state) => TransitionMatrix state -> Bool +converges :: TransitionMatrix state -> Bool converges p = all ((== Just 1) . classPeriod) diff --git a/src/Dtmc/Analysis/LinearSystem/Internal.hs b/src/Dtmc/Analysis/LinearSystem/Internal.hs --- a/src/Dtmc/Analysis/LinearSystem/Internal.hs +++ b/src/Dtmc/Analysis/LinearSystem/Internal.hs @@ -20,6 +20,8 @@ fundamental, ) where +import Data.List qualified as List +import Data.Vector.Storable qualified as Storable import Dtmc.Analysis.LinearSystem ( LinearSystemError (..), ) @@ -32,14 +34,49 @@ residualLimitValue = 1e-9 allFinite :: LA.Matrix Double -> Bool -allFinite = all isFinite . LA.toList . LA.flatten +allFinite = Storable.all isFinite . LA.flatten isFinite :: Double -> Bool isFinite value = not (isNaN value || isInfinite value) infinityNorm :: LA.Matrix Double -> Double -infinityNorm = maximum . (0 :) . map (sum . map abs) . LA.toLists +infinityNorm = maximumAbsoluteSum . LA.toRows +oneNorm :: LA.Matrix Double -> Double +oneNorm = maximumAbsoluteSum . LA.toColumns + +maximumAbsoluteSum :: [LA.Vector Double] -> Double +maximumAbsoluteSum = + List.foldl' max 0 + . map (Storable.foldl' (\acc value -> acc + abs value) 0) + +maximumAbsolute :: LA.Vector Double -> Double +maximumAbsolute = Storable.foldl' (\acc value -> max acc (abs value)) 0 + +reciprocalConditionForIminusQ :: + LA.Matrix Double -> + LA.Vector Double -> + Double +reciprocalConditionForIminusQ coefficient inverseTimesOne + | Storable.all isFinite inverseTimesOne + && isFinite provenLowerBound + && provenLowerBound >= conditionLimit = + provenLowerBound + | otherwise = LA.rcond coefficient + where + inverseInfinityNorm = maximumAbsolute inverseTimesOne + -- The inverse one-norm is at most n times its infinity norm, and every + -- spectral norm is at most the square root of one-norm times infinity norm. + provenLowerBound = + 1 + / ( inverseInfinityNorm + * sqrt + ( fromIntegral (LA.rows coefficient) + * oneNorm coefficient + * infinityNorm coefficient + ) + ) + relativeSystemResidual :: LA.Matrix Double -> LA.Matrix Double -> @@ -53,6 +90,28 @@ + infinityNorm rightHandSide ) +validateSolution :: + LA.Matrix Double -> + LA.Matrix Double -> + LA.Matrix Double -> + Double -> + Either LinearSystemError (LA.Matrix Double) +validateSolution coefficient rightHandSide solution reciprocalCondition + | not (allFinite solution) = Left NonFiniteSolution + | not (isFinite reciprocalCondition) = Left NonFiniteSystem + | reciprocalCondition < conditionLimit = + Left (IllConditionedSystem reciprocalCondition) + | residual > residualLimitValue = + Left + ( ResidualTooLarge + { relativeResidual = residual + , residualLimit = residualLimitValue + } + ) + | otherwise = Right solution + where + residual = relativeSystemResidual coefficient solution rightHandSide + {- | Solve @A X = B@ by LU decomposition. @A@ must be a non-empty square matrix, @B@ must have the same number of rows, and all entries must be finite; incompatible dimensions raise a backend error. @@ -75,22 +134,12 @@ | otherwise = case LA.linearSolve coefficient rightHandSide of Nothing -> Left SingularSystem - Just solution - | not (allFinite solution) -> Left NonFiniteSolution - | not (isFinite reciprocalCondition) -> Left NonFiniteSystem - | reciprocalCondition < conditionLimit -> - Left (IllConditionedSystem reciprocalCondition) - | residual > residualLimitValue -> - Left - ( ResidualTooLarge - { relativeResidual = residual - , residualLimit = residualLimitValue - } - ) - | otherwise -> Right solution - where - residual = - relativeSystemResidual coefficient solution rightHandSide + Just solution -> + validateSolution + coefficient + rightHandSide + solution + reciprocalCondition where reciprocalCondition = LA.rcond coefficient @@ -120,16 +169,23 @@ rowSums :: LA.Matrix Double -> LA.Vector Double rowSums m = m LA.#> LA.konst 1 (LA.cols m) -{- | Solve @(I - Q) X = B@ by LU decomposition. @Q@ must be @n x n@, @B@ -must be @n x r@, and all entries must be finite; incompatible dimensions -raise a backend error. +{- | Solve @(I - Q) X = B@ by one LU decomposition. @Q@ must be a +transient-to-transient, substochastic @n x n@ matrix, @B@ must be @n x r@, +and all entries must be finite; incompatible dimensions raise a backend +error. Returns a 'LinearSystemError' when the input or result is non-finite, the backend reports singularity, the reciprocal condition estimate is below -@1e-12@, or the scaled infinity-norm residual exceeds @1e-9@. Current DTMC -callers choose @Q@ with spectral radius below one, which guarantees -invertibility in exact arithmetic but not a reliable 'Double' result. +@1e-12@, or the scaled infinity-norm residual exceeds @1e-9@. +The solve appends a column of ones to @B@. Since @(I - Q)^-1@ is +non-negative, the extra result gives its exact infinity norm in exact +arithmetic. Matrix-norm inequalities then provide a conservative lower bound +on the reciprocal 2-norm condition number. A bound above the acceptance limit +proves that the solution is sufficiently conditioned without a separate +singular-value decomposition; uncertain cases retain the backend condition +estimate and therefore the same rejection threshold. + Complexity: @O(n^3 + n^2 r)@ time, @O(n^2 + n r)@ temporary space, and @O(n r)@ result space for @r@ right-hand sides. -} @@ -138,10 +194,34 @@ LA.Matrix Double -> Either LinearSystemError (LA.Matrix Double) solveIminusQ q rightHandSide - | not (allFinite q) = Left NonFiniteSystem - | otherwise = solveLinearSystem coefficient rightHandSide + | not (allFinite q && allFinite rightHandSide) = Left NonFiniteSystem + | otherwise = + case LA.linearSolve coefficient augmentedRightHandSide of + Nothing -> Left SingularSystem + Just augmentedSolution -> + let solution = + LA.takeColumns + rightHandSideColumns + augmentedSolution + inverseTimesOne = + LA.flatten + ( LA.dropColumns + rightHandSideColumns + augmentedSolution + ) + in validateSolution + coefficient + rightHandSide + solution + ( reciprocalConditionForIminusQ + coefficient + inverseTimesOne + ) where coefficient = LA.ident (LA.rows q) - q + rightHandSideColumns = LA.cols rightHandSide + augmentedRightHandSide = + rightHandSide LA.||| LA.asColumn (LA.konst 1 (LA.rows q)) {- | Solve @(I - Q) x = b@ for a vector of length @n@. This has the same shape requirements, numerical behaviour, and errors as 'solveIminusQ'. diff --git a/src/Dtmc/Analysis/ReturnTime.hs b/src/Dtmc/Analysis/ReturnTime.hs --- a/src/Dtmc/Analysis/ReturnTime.hs +++ b/src/Dtmc/Analysis/ReturnTime.hs @@ -43,6 +43,9 @@ Map, ) import Data.Map.Strict qualified as Map +import Data.Maybe ( + fromMaybe, + ) import Dtmc.Analysis.Classification ( recurrentState, transientStates, @@ -53,6 +56,12 @@ import Dtmc.Analysis.Expectation ( Expectation (..), ) +import Dtmc.Analysis.FiniteHorizon.Internal ( + branchingDenseBackend, + denseExactReturnProbability, + denseLowerReturnProbability, + denseUpperReturnProbability, + ) import Dtmc.Analysis.Initial.Internal ( expectationUnderEither, probabilityUnder, @@ -130,8 +139,12 @@ Double exactProbabilityAt 0 _ _ = 0 exactProbabilityAt time kernel initialState = - go time (Map.singleton initialState 1) + fromMaybe genericProbability optimizedProbability where + optimizedProbability = do + backend <- branchingDenseBackend kernel [initialState] + pure (denseExactReturnProbability time backend initialState) + genericProbability = go time (Map.singleton initialState 1) isInitial state = state == initialState go 0 _ = 0 @@ -157,9 +170,14 @@ kernel -> TransitionState kernel -> Double +lowerTailProbability bound _ _ | bound <= 1 = 0 lowerTailProbability bound kernel initialState = - go bound (Map.singleton initialState 1) 0 + fromMaybe genericProbability optimizedProbability where + optimizedProbability = do + backend <- branchingDenseBackend kernel [initialState] + pure (denseLowerReturnProbability bound backend initialState) + genericProbability = go bound (Map.singleton initialState 1) 0 isInitial state = state == initialState go remaining _ total | remaining <= 1 = total @@ -319,9 +337,14 @@ kernel -> TransitionState kernel -> Double +upperTailProbability 0 _ _ = 1 upperTailProbability time kernel initialState = - go time (Map.singleton initialState 1) + fromMaybe genericProbability optimizedProbability where + optimizedProbability = do + backend <- branchingDenseBackend kernel [initialState] + pure (denseUpperReturnProbability time backend initialState) + genericProbability = go time (Map.singleton initialState 1) isInitial state = state == initialState go 0 survivors = sum (Map.elems survivors) go _ survivors | Map.null survivors = 0 @@ -372,7 +395,11 @@ are per-step upper bounds on survivor states, traversed transition edges, and accumulated destinations. -Complexity: excluding 'transitionLaw', +For a 'TransitionMatrix' whose initial row branches, an internal adaptive path +uses dense matrix-vector multiplication in @O(k n^2)@ time and @O(n)@ +temporary space. A deterministic initial row retains the sparse recurrence. + +Generic complexity: excluding 'transitionLaw', @O(k (w + e log(u + 1) + u) + 1)@ time, @O(w + u)@ temporary space, and @O(1)@ result space. -} diff --git a/src/Dtmc/Analysis/Stationary.hs b/src/Dtmc/Analysis/Stationary.hs --- a/src/Dtmc/Analysis/Stationary.hs +++ b/src/Dtmc/Analysis/Stationary.hs @@ -29,24 +29,11 @@ stationaryDistributions, ) where -import Control.Monad.ST ( - ST, - runST, - ) -import Data.Array.MArray ( - newListArray, - readArray, - writeArray, - ) -import Data.Array.ST ( - STUArray, - ) +import Control.Monad.ST (runST) import Data.Array.Unboxed qualified as Unboxed -import Dtmc.Analysis.Classification ( - classClosed, - classMembers, - communicatingClasses, - ) +import Data.Maybe (fromMaybe) +import Data.Vector.Storable qualified as Storable +import Data.Vector.Storable.Mutable qualified as Mutable import Dtmc.Analysis.LinearSystem ( LinearSystemError (..), ) @@ -61,18 +48,23 @@ ) import Dtmc.State.Internal ( stateCardinalityInt, - stateIndexInt, + stateFromInt, ) import Dtmc.Transition.Matrix ( TransitionMatrix, ) import Dtmc.Transition.Matrix.Internal ( + tmSupport, unTransitionMatrix, ) +import Dtmc.Transition.Matrix.Internal.Graph qualified as G import Numeric.LinearAlgebra qualified as LA -toIndex :: (FiniteState state) => state -> Int -toIndex = stateIndexInt +toState :: (FiniteState state) => Int -> state +toState index = + fromMaybe + (error "Dtmc.Analysis.Stationary: graph vertex out of bounds") + (stateFromInt index) {- | Compute the stationary vector of a non-empty irreducible stochastic block, in the block's own ordering, by Grassmann-Taksar-Heyman state @@ -111,19 +103,33 @@ Either LinearSystemError (LA.Vector Double) stationaryOfBlock block | dimension == 0 = Left SingularSystem - | not (all isFinite (LA.toList (LA.flatten block))) = Left NonFiniteSystem + | not (Storable.all isFinite flattened) = Left NonFiniteSystem + | dimension == 1 = singletonSolution | otherwise = - case reduceGth dimension (LA.toList (LA.flatten block)) of + case reduceGth dimension flattened of Nothing -> Left SingularSystem Just weights -> normalise weights where dimension = LA.rows block + flattened = LA.flatten block + singletonSolution + | residual > limit = + Left + ( ResidualTooLarge + { relativeResidual = residual + , residualLimit = limit + } + ) + | otherwise = Right (Storable.singleton 1) + where + limit = 1e-9 + residual = abs (flattened Storable.! 0 - 1) normalise weights - | not (all isFinite weights) = Left NonFiniteSolution + | not (Storable.all isFinite weights) = Left NonFiniteSolution | scale <= 0 = Left SingularSystem | not (isFinite total) = Left NonFiniteSolution | total <= 0 = Left SingularSystem - | not (all isFinite stationaryWeights) = Left NonFiniteSolution + | not (Storable.all isFinite stationary) = Left NonFiniteSolution | not (isFinite residual) = Left NonFiniteSolution | residual > limit = Left @@ -135,22 +141,19 @@ | otherwise = Right stationary where limit = 1e-9 - scale = maximum weights - scaledWeights = map (/ scale) weights - total = sum scaledWeights - stationaryWeights = map (/ total) scaledWeights - stationary = LA.fromList stationaryWeights + scale = Storable.maximum weights + scaledWeights = Storable.map (/ scale) weights + total = Storable.sum scaledWeights + stationary = Storable.map (/ total) scaledWeights residual = - foldr (max . abs) 0 (LA.toList (LA.tr block LA.#> stationary - stationary)) + Storable.foldl' + (\largest value -> max largest (abs value)) + 0 + (LA.tr block LA.#> stationary - stationary) isFinite :: Double -> Bool isFinite value = not (isNaN value || isInfinite value) --- Allocating through a signature that quantifies the state thread keeps the --- array type unambiguous without local annotations inside 'runST'. -newFlatArray :: (Int, Int) -> [Double] -> ST s (STUArray s Int Double) -newFlatArray = newListArray - {- | Compute the unnormalised GTH weights of an @n x n@ block supplied in row-major order. Return 'Nothing' when an elimination step finds no positive way out of the state being removed. @@ -161,26 +164,42 @@ Complexity: @O(n^3)@ time, @O(n^2)@ temporary space, and @O(n)@ result space. -} -reduceGth :: Int -> [Double] -> Maybe [Double] +reduceGth :: Int -> Storable.Vector Double -> Maybe (Storable.Vector Double) reduceGth n entries = runST $ do - a <- newFlatArray (0, n * n - 1) entries + a <- Storable.thaw entries let index i j = i * n + j - exitMass k = - sum <$> mapM (readArray a . index k) [0 .. k - 1] + exitMass k = sumRow 0 0 + where + sumRow j total + | j >= k = pure total + | otherwise = do + value <- Mutable.unsafeRead a (index k j) + let next = total + value + next `seq` sumRow (j + 1) next absorbRow k s i = do - entering <- readArray a (index i k) + entering <- Mutable.unsafeRead a (index i k) let scaled = entering / s - writeArray a (index i k) scaled - mapM_ - ( \j -> do - leaving <- readArray a (index k j) - current <- readArray a (index i j) - writeArray a (index i j) (current + scaled * leaving) - ) - [0 .. k - 1] + Mutable.unsafeWrite a (index i k) scaled + updateColumns 0 scaled + where + updateColumns j scaled + | j >= k = pure () + | otherwise = do + leaving <- Mutable.unsafeRead a (index k j) + current <- Mutable.unsafeRead a (index i j) + Mutable.unsafeWrite a (index i j) (current + scaled * leaving) + updateColumns (j + 1) scaled + absorbRows k s = updateRow 0 + where + updateRow i + | i >= k = pure () + | otherwise = do + absorbRow k s i + updateRow (i + 1) + eliminate k | k < 1 = pure True | otherwise = do @@ -188,22 +207,33 @@ if s <= 0 then pure False else do - mapM_ (absorbRow k s) [0 .. k - 1] + absorbRows k s eliminate (k - 1) - -- visits holds x(0) .. x(k-1) in order. - substitute k visits - | k >= n = pure visits + substitute visits k + | k >= n = pure () | otherwise = do - terms <- - mapM - (\(i, x) -> (x *) <$> readArray a (index i k)) - (zip [0 ..] visits) - substitute (k + 1) (visits ++ [sum terms]) + value <- substitutionTerm visits k + Mutable.unsafeWrite visits k value + substitute visits (k + 1) + substitutionTerm visits k = accumulate 0 0 + where + accumulate i total + | i >= k = pure total + | otherwise = do + visitsAtI <- Mutable.unsafeRead visits i + factor <- Mutable.unsafeRead a (index i k) + let next = total + visitsAtI * factor + next `seq` accumulate (i + 1) next + feasible <- eliminate (n - 1) if feasible - then Just <$> substitute 1 [1] + then do + visits <- Mutable.replicate n 0 + Mutable.unsafeWrite visits 0 1 + substitute visits 1 + Just <$> Storable.freeze visits else pure Nothing {- | Compute the extremal stationary distributions, one per recurrent class @@ -240,9 +270,13 @@ where dim = stateCardinalityInt @state matrix = unTransitionMatrix p + graph = tmSupport p closedClasses = - [classMembers c | c <- communicatingClasses p, classClosed c] - distributionOn members = do + [ (map toState indices, indices) + | indices@(first : _) <- G.components graph + , G.inClosedComponent graph first + ] + distributionOn (members, indices) = do solution <- stationaryOfBlock (subMatrix indices indices matrix) let placed :: Unboxed.UArray Int Double placed = @@ -255,5 +289,3 @@ ( members , DistributionVector (LA.fromList [placed Unboxed.! i | i <- [0 .. dim - 1]]) ) - where - indices = map toIndex members diff --git a/src/Dtmc/Analysis/VisitCount.hs b/src/Dtmc/Analysis/VisitCount.hs --- a/src/Dtmc/Analysis/VisitCount.hs +++ b/src/Dtmc/Analysis/VisitCount.hs @@ -58,7 +58,7 @@ communicatingClasses, recurrentState, ) -import Dtmc.Analysis.Classification.Internal ( +import Dtmc.Analysis.Classification.Reachability.Internal ( backwardReachable, ) import Dtmc.Analysis.Event ( @@ -68,6 +68,10 @@ import Dtmc.Analysis.Expectation ( Expectation (..), ) +import Dtmc.Analysis.FiniteHorizon.Internal ( + branchingDenseBackend, + denseBoundedVisitExpectation, + ) import Dtmc.Analysis.HittingTime qualified as Hit import Dtmc.Analysis.Initial.Internal ( expectationUnderEither, @@ -377,7 +381,12 @@ support size, and @w@, @e@, and @u@ are per-step upper bounds on stored source states, traversed transition edges, and accumulated destination states. -Complexity: excluding the initial 'distributionWeights' call, +For a 'TransitionMatrix' with a branching row in the initial support, an +internal adaptive path uses dense matrix-vector multiplication in +@O(n log(s + 1) + k n^2)@ time and @O(n)@ temporary space. Deterministic +initial rows retain the sparse recurrence. + +Generic complexity: excluding the initial 'distributionWeights' call, 'transitionLaw', and predicate evaluation, @O(s log(s + 1) + k (w + e log(u + 1) + u))@ time, @O(w + u)@ temporary space, and @O(1)@ result space. At @k = 0@ the function takes @O(1)@ time and @@ -394,9 +403,23 @@ transition -> (TransitionState transition -> Bool) -> Double +boundedExpectation 0 _ _ _ = 0 boundedExpectation bound initial transition isVisited = - go bound (Map.fromList (distributionWeights initial)) 0 + case optimizedExpectation of + Just expectation -> expectation + Nothing -> go bound initialWeights 0 where + initialWeights = Map.fromList (distributionWeights initial) + optimizedExpectation = do + backend <- branchingDenseBackend transition (Map.keys initialWeights) + pure + ( denseBoundedVisitExpectation + bound + initialWeights + backend + isVisited + ) + go 0 _ expectation = expectation go remaining weights expectation = let visitProbability = diff --git a/src/Dtmc/Dynamics.hs b/src/Dtmc/Dynamics.hs --- a/src/Dtmc/Dynamics.hs +++ b/src/Dtmc/Dynamics.hs @@ -63,16 +63,17 @@ evolveVector (DistributionVector v) p = DistributionVector (LA.tr (unTransitionMatrix p) LA.#> v) -{- | Compute the distribution after @k@ transitions as -@evolveVector mu (power k p)@. Exponent zero is the original distribution -mathematically. +{- | Compute the distribution after @k@ transitions. A cost model chooses +between repeated matrix-vector multiplication and powering the matrix, so a +moderate number of steps does not construct a full matrix power unnecessarily. +Exponent zero returns the original distribution. -This powers the matrix rather than iterating 'evolveVector', so the two -calculations may differ by floating-point rounding. The result is not -revalidated. +The two strategies are mathematically equivalent but may differ by ordinary +floating-point rounding. The result is not revalidated. -Complexity: @O(n^2 + n^3 log(k + 1))@ time, @O(n^2)@ temporary space, and -@O(n)@ result space. +Complexity: @O(k n^2)@ time when @k <= n@ and +@O(n^2 + n^3 log(k + 1))@ otherwise. Temporary space is @O(n)@ in the +iterated case and @O(n^2)@ in the powered case; result space is @O(n)@. -} evolveVectorN :: (FiniteState state) => @@ -80,8 +81,25 @@ DistributionVector state -> TransitionMatrix state -> DistributionVector state -evolveVectorN k mu p = - evolveVector mu (power k p) +evolveVectorN k mu@(DistributionVector initial) p + | k == 0 = mu + | useIteration = DistributionVector (iterateVector k initial) + | otherwise = evolveVector mu (power k p) + where + matrix = unTransitionMatrix p + transposed = LA.tr matrix + dimension = LA.rows matrix + + -- A deliberately conservative threshold retains the highly tuned matrix + -- power path for long runs on small matrices. Focused benchmarks show the + -- repeated matrix-vector path winning once the matrix dimension reaches + -- the requested step count. + useIteration = toInteger k <= toInteger dimension + + iterateVector 0 vector = vector + iterateVector remaining vector = + let next = transposed LA.#> vector + in next `seq` iterateVector (remaining - 1) next {- | Push any finite-support 'Distribution' through one locally finite kernel step. The result uses t'DistributionMap' because a general kernel does not diff --git a/src/Dtmc/Simulation.hs b/src/Dtmc/Simulation.hs --- a/src/Dtmc/Simulation.hs +++ b/src/Dtmc/Simulation.hs @@ -13,12 +13,16 @@ sample, step, simulate, + simulateMatrix, ) where +import Control.Monad (when) import Control.Monad.Primitive ( PrimMonad, PrimState, ) +import Data.Array qualified as Array +import Data.Array.Unboxed qualified as Unboxed import Data.List qualified as List import Dtmc.Distribution ( Distribution (..), @@ -26,9 +30,20 @@ import Dtmc.Simplex.Internal ( simplexTolerance, ) +import Dtmc.State ( + FiniteState, + ) +import Dtmc.State.Internal ( + stateFromInt, + stateIndexInt, + ) import Dtmc.Transition ( Transition (..), ) +import Dtmc.Transition.Matrix.Internal ( + TransitionMatrix, + unTransitionMatrix, + ) import Numeric.LinearAlgebra qualified as LA import Numeric.Natural ( Natural, @@ -155,3 +170,109 @@ case result of Left problem -> pure (Left problem) Right next -> go (remaining - 1) next (next : reversed) + +-- | A validated cumulative row used by 'simulateMatrix'. The final positive +-- index is retained as a defensive fallback if the random generator returns +-- the upper endpoint of its requested floating-point interval. +data PreparedMatrixRow = PreparedMatrixRow + !(Unboxed.UArray Int Int) + !(LA.Vector Double) + !Double + !Int + +{- | Simulate a finite transition matrix without converting every visited row +to a map-backed distribution. Each distinct row is validated and converted to +a shared cumulative vector on first use; sampling that row thereafter uses a +binary search. + +This has the same validation and generator-advancement contract as 'simulate': +an invalid visited row is reported before drawing a random number, unvisited +rows are not inspected, and a zero-step simulation inspects neither the matrix +nor the generator. + +For matrix dimension @n@, @k@ transitions, and @r@ distinct visited rows, +complexity is @O(r n + k log n)@ time, @O(r n + n + k)@ temporary space, and +@O(k)@ result space. The row cache lives only for this simulation call. +-} +simulateMatrix :: + forall state m. + (FiniteState state, PrimMonad m) => + Natural -> + TransitionMatrix state -> + state -> + MWC.Gen (PrimState m) -> + m (Either SimulationError [state]) +simulateMatrix 0 _ initial _ = pure (Right [initial]) +simulateMatrix transitions matrix initial generator = + go transitions initial [initial] + where + stored = unTransitionMatrix matrix + dimension = LA.rows stored + + -- 'Array' is lazy in its elements, so only rows reached by the trajectory + -- are converted and validated. Forced entries are then shared. + preparedRows :: Array.Array Int (Either SimulationError PreparedMatrixRow) + preparedRows = + Array.listArray + (0, dimension - 1) + [prepareMatrixRow (LA.toList row) | row <- LA.toRows stored] + + go 0 _ reversed = pure (Right (reverse reversed)) + go remaining current reversed = + case preparedRows Array.! stateIndexInt current of + Left problem -> pure (Left problem) + Right prepared -> do + index <- samplePreparedMatrixRow prepared generator + case stateFromInt index of + Nothing -> + pure + (Left (SampleIndexOutOfBounds index dimension)) + Just next -> + go (remaining - 1) next (next : reversed) + +prepareMatrixRow :: [Double] -> Either SimulationError PreparedMatrixRow +prepareMatrixRow weights = do + let entries = filter ((/= 0) . snd) (zip [0 ..] weights) + when (null entries) (Left EmptySupport) + repaired <- traverse repairWeight (zip [0 ..] (map snd entries)) + let cumulative = drop 1 (List.scanl' (+) 0 repaired) + total = List.foldl' (+) 0 repaired + validateTotal total + let lastPositive = + List.foldl' + (\latest (index, weight) -> if weight > 0 then index else latest) + 0 + (zip [0 ..] repaired) + outcomes = + Unboxed.listArray + (0, length entries - 1) + (map fst entries) + pure + ( PreparedMatrixRow + outcomes + (LA.fromList cumulative) + total + lastPositive + ) + +samplePreparedMatrixRow :: + (PrimMonad m) => + PreparedMatrixRow -> + MWC.Gen (PrimState m) -> + m Int +samplePreparedMatrixRow + (PreparedMatrixRow outcomes cumulative total lastPositive) + generator = do + target <- MWC.uniformR (0, total) generator + pure (outcomes Unboxed.! firstGreater target cumulative lastPositive) + +firstGreater :: Double -> LA.Vector Double -> Int -> Int +firstGreater target cumulative fallback = search 0 (LA.size cumulative) + where + search lower upper + | lower >= upper = + if lower < LA.size cumulative then lower else fallback + | cumulative `LA.atIndex` middle > target = search lower middle + | otherwise = search (middle + 1) upper + where + middle = lower + (upper - lower) `quot` 2 diff --git a/src/Dtmc/Transition.hs b/src/Dtmc/Transition.hs --- a/src/Dtmc/Transition.hs +++ b/src/Dtmc/Transition.hs @@ -8,28 +8,9 @@ "Dtmc.Transition.Matrix" and "Dtmc.Transition.Kernel". -} module Dtmc.Transition ( - Transition (..), + Transition (TransitionState, transitionLaw), ) where -import Dtmc.Distribution.Map (DistributionMap) - -{- | A time-homogeneous transition rule whose law from any supplied state has -finite support. The complete state space may be finite or infinite. - -This capability is sufficient for exact finite-horizon map-backed algorithms. -It does not imply that states can be enumerated, so it cannot by itself support -generic classification, stationary, eventual-hitting, or expectation -algorithms. --} -class Transition transition where - -- | State type governed by this transition representation. - type TransitionState transition - - {- | Return the validated finite-support law of the next state. - - Complexity: implementation-dependent. - -} - transitionLaw :: - transition -> - TransitionState transition -> - DistributionMap (TransitionState transition) +import Dtmc.Transition.Internal ( + Transition (TransitionState, transitionLaw), + ) diff --git a/src/Dtmc/Transition/Internal.hs b/src/Dtmc/Transition/Internal.hs new file mode 100644 --- /dev/null +++ b/src/Dtmc/Transition/Internal.hs @@ -0,0 +1,89 @@ +{-# OPTIONS_HADDOCK not-home #-} + +{- | +Module : Dtmc.Transition.Internal +Description : Transition class and optional dense finite-state backend. + +The public "Dtmc.Transition" module exposes only 'TransitionState' and +'transitionLaw'. The remaining method exposes an optional representation +capability, kept internal so optimized library analyses do not enlarge the +public API or burden third-party instances. +-} +module Dtmc.Transition.Internal ( + DenseTransitionBackend (..), + denseRowBranches, + Transition (..), +) where + +import Data.Vector.Storable qualified as Storable +import Dtmc.Distribution.Map ( + DistributionMap, + ) +import Numeric.LinearAlgebra qualified as LA + +{- | Dense finite-state data shared by representation-specific analysis +implementations. State order, indexing, and the matrix must describe the same +canonical coordinate system. + +This type is internal: public transition instances need only implement +'transitionLaw'. +-} +data DenseTransitionBackend state = DenseTransitionBackend + { denseTransitionMatrix :: LA.Matrix Double + , denseTransitionStates :: [state] + , denseTransitionIndex :: state -> Int + } + +{- | Test whether one stored row has more than one positive transition. The +scan stops after its second positive entry. +-} +denseRowBranches :: DenseTransitionBackend state -> state -> Bool +denseRowBranches backend state = go 0 0 + where + stored = denseTransitionMatrix backend + rowIndex = denseTransitionIndex backend state + entries = + LA.flatten + ( LA.subMatrix + (rowIndex, 0) + (1, LA.cols stored) + stored + ) + entryCount = Storable.length entries + + go :: Int -> Int -> Bool + go offset positiveCount + | positiveCount > 1 = True + | offset == entryCount = False + | entries Storable.! offset > 0 = go (offset + 1) (positiveCount + 1) + | otherwise = go (offset + 1) positiveCount + +{- | A time-homogeneous transition rule whose law from any supplied state has +finite support. The complete state space may be finite or infinite. + +This capability is sufficient for exact finite-horizon map-backed algorithms. +It does not imply that states can be enumerated, so it cannot by itself support +generic classification, stationary, eventual-hitting, or expectation +algorithms. +-} +class Transition transition where + -- | State type governed by this transition representation. + type TransitionState transition + + {- | Return the validated finite-support law of the next state. + + Complexity: implementation-dependent. + -} + transitionLaw :: + transition -> + TransitionState transition -> + DistributionMap (TransitionState transition) + + -- Optional representation capability. Existing and third-party instances + -- inherit the locally finite, representation-independent fallback. + transitionDenseBackend :: + transition -> + Maybe (DenseTransitionBackend (TransitionState transition)) + transitionDenseBackend _ = Nothing + + {-# MINIMAL transitionLaw #-} diff --git a/src/Dtmc/Transition/Matrix.hs b/src/Dtmc/Transition/Matrix.hs --- a/src/Dtmc/Transition/Matrix.hs +++ b/src/Dtmc/Transition/Matrix.hs @@ -85,8 +85,8 @@ {- | Construct a row-stochastic matrix from a grid of weights in canonical state order, stopping at the first problem. Within each accepted row, tolerated coordinate error is clamped to @[0, 1]@ and the repaired row is -normalised. The support graph remains lazy, and the empty @0 x 0@ matrix is -accepted. +normalised. The support graph and classification cache remain lazy, and the +empty @0 x 0@ matrix is accepted. This inverts 'toRows' up to that repair and needs no @hmatrix@ value: the shape is checked here and reported as 'WrongRowCount' or 'WrongRowWidth' @@ -117,8 +117,8 @@ {- | Materialise a finite-state kernel as a dense transition matrix. Kernel rows are already validated 'Dtmc.Distribution.Map.DistributionMap' values, so this conversion is total and performs no additional clamping or -renormalisation. Missing coordinates become exact zeros. The support graph -remains lazy, and the empty @0 x 0@ matrix is accepted. +renormalisation. Missing coordinates become exact zeros. The support graph and +classification cache remain lazy, and the empty @0 x 0@ matrix is accepted. Complexity: excluding evaluation of 'finiteStates' and the kernel laws, @O(n^2)@ time and @O(n^2)@ temporary and result space. @@ -155,7 +155,7 @@ multiplication mathematically, but floating-point rounding can accumulate. Complexity: @O(n^3)@ worst-case time and @O(n^2)@ temporary and result space. -The support graph is built lazily. +The support graph and classification cache are built lazily. -} compose :: TransitionMatrix state -> diff --git a/src/Dtmc/Transition/Matrix/Internal.hs b/src/Dtmc/Transition/Matrix/Internal.hs --- a/src/Dtmc/Transition/Matrix/Internal.hs +++ b/src/Dtmc/Transition/Matrix/Internal.hs @@ -1,11 +1,13 @@ +{-# LANGUAGE GADTs #-} + {- | Module : Dtmc.Transition.Matrix.Internal Description : Raw carrier for transition matrices (unsafe underbelly). Raw carrier behind t'Dtmc.Transition.Matrix.TransitionMatrix': an hmatrix -matrix paired with its lazy support graph. The public smart constructor -validates its square shape and canonicalises rows; this internal module -exposes unchecked construction. +matrix paired with its lazy support graph and complete classification. The +public smart constructor validates its square shape and canonicalises rows; +this internal module exposes unchecked construction. The constructor is positional so the public matrix projection cannot act as a record-update setter and desynchronise the matrix from its cached graph. @@ -14,10 +16,17 @@ TransitionMatrix (TransitionMatrix), unTransitionMatrix, tmSupport, + tmClassification, unsafeTransitionMatrix, matrixRowAt, ) where +import Data.Maybe (fromMaybe) +import Data.Vector.Storable qualified as Storable +import Dtmc.Analysis.Classification.Internal ( + Classification, + classificationFromGraph, + ) import Dtmc.Distribution.Map ( fromDistribution, ) @@ -26,12 +35,15 @@ ) import Dtmc.State ( FiniteState, + finiteStates, ) import Dtmc.State.Internal ( stateCardinalityInt, + stateFromInt, stateIndexInt, ) -import Dtmc.Transition ( +import Dtmc.Transition.Internal ( + DenseTransitionBackend (..), Transition (..), ) import Dtmc.Transition.Matrix.Internal.Graph ( @@ -47,14 +59,19 @@ tolerant row validation and canonicalisation. The internal constructor and arithmetic instances do not revalidate. -Each value also carries its support graph as a /lazy/ second argument, so any -graph-based analyses on the same value share one build. Construct internal -values with @unsafeTransitionMatrix@ rather than pairing a matrix and graph -directly. +Each value also carries its support graph and complete typed classification as +/lazy/ arguments, so graph-based analyses on the same value share both the +graph build and public classification results. Construct internal values with +@unsafeTransitionMatrix@ rather than pairing these fields directly. -} -data TransitionMatrix state - = -- | Unchecked matrix/cache pair; the graph must match the matrix. - TransitionMatrix (LA.Matrix Double) Graph +data TransitionMatrix state where + -- | Unchecked matrix/cache triple; both caches must match the matrix. + TransitionMatrix :: + (FiniteState state) => + LA.Matrix Double -> + Graph -> + Classification state -> + TransitionMatrix state -- Nominal role prevents coercion between distinct state types, including -- state types with the same cardinality. @@ -67,7 +84,7 @@ unTransitionMatrix :: TransitionMatrix state -> LA.Matrix Double -unTransitionMatrix (TransitionMatrix matrix _) = matrix +unTransitionMatrix (TransitionMatrix matrix _ _) = matrix {- | Return the lazy support graph, with edge @i -> j@ exactly when the stored entry is strictly positive. No tolerance is applied: a tiny positive rounding @@ -80,8 +97,21 @@ space; the resulting graph occupies @O(n + E)@ space for @E@ support edges. -} tmSupport :: TransitionMatrix state -> Graph -tmSupport (TransitionMatrix _ support) = support +tmSupport (TransitionMatrix _ support _) = support +{- | Return the lazy complete classification associated with the matrix. +Whole-chain classification queries on the same matrix therefore share their +typed classes and state lists as well as the underlying graph facts. + +Complexity: @O(1)@ projection time and space. The first full evaluation takes +the classification cost documented by +'Dtmc.Analysis.Classification.communicatingClasses'; later projections reuse +the retained @O(n)@ classification. +-} +tmClassification :: TransitionMatrix state -> Classification state +tmClassification (TransitionMatrix _ _ classification) = classification +{-# INLINE tmClassification #-} + -- Manual 'Show': 'Graph' has no 'Show', and the derived cache should not -- appear in the rendering. instance Show (TransitionMatrix state) where @@ -90,19 +120,28 @@ showString "TransitionMatrix " . showsPrec 11 (unTransitionMatrix p) -{- | Pair a raw matrix with its lazy support graph. This performs no -row-stochastic, finiteness, or simplex validation; internal callers must -establish the required invariant. +{- | Pair a raw matrix with its lazy support graph and classification. This +performs no row-stochastic, finiteness, or simplex validation; internal +callers must establish the required invariant. Complexity: @O(1)@ construction time and @O(1)@ construction space. Forcing the support graph takes @O(n^2)@ time and @O(n^2)@ temporary space; the graph occupies @O(n + E)@ space for @E@ support edges. -} unsafeTransitionMatrix :: + (FiniteState state) => LA.Matrix Double -> TransitionMatrix state unsafeTransitionMatrix matrix = - TransitionMatrix matrix (supportGraphOf matrix) + TransitionMatrix matrix support classification + where + support = supportGraphOf matrix + classification = classificationFromGraph toState support + toState index = + fromMaybe + (error "Dtmc.Transition.Matrix.Internal: graph vertex out of bounds") + (stateFromInt index) +{-# INLINE unsafeTransitionMatrix #-} {- | Wrap one stored matrix row as a distribution vector without revalidation. The finite-state index makes the lookup total. @@ -132,21 +171,29 @@ transitionLaw matrix = fromDistribution . matrixRowAt matrix + transitionDenseBackend matrix = + Just + DenseTransitionBackend + { denseTransitionMatrix = unTransitionMatrix matrix + , denseTransitionStates = finiteStates + , denseTransitionIndex = stateIndexInt + } + -- Use strict positivity without tolerance so graph queries reflect the stored -- matrix exactly; keep construction here so the cache cannot become stale. supportGraphOf :: LA.Matrix Double -> Graph supportGraphOf matrix = - fromAdjacency - dim - [ ((i, j), entry > 0) - | (i, row) <- zip [0 ..] rows - , (j, entry) <- zip [0 ..] row - ] + fromAdjacency dim associations where - rows = LA.toLists matrix - dim = length rows + dim = LA.rows matrix + associations = Storable.ifoldr associationFor [] (LA.flatten matrix) + associationFor offset probability rest = + let (row, column) = offset `quotRem` dim + in row `seq` + column `seq` + ((row, column), probability > 0) : rest {- | Matrix multiplication as transition composition: @p '<>' q@ takes a @p@ step followed by a @q@ step. Exact products preserve row-stochasticity and @@ -158,7 +205,8 @@ TransitionMatrix state -> TransitionMatrix state -> TransitionMatrix state - p <> q = unsafeTransitionMatrix (unTransitionMatrix p LA.<> unTransitionMatrix q) + p@TransitionMatrix{} <> q = + unsafeTransitionMatrix (unTransitionMatrix p LA.<> unTransitionMatrix q) {- | The identity matrix represents zero transitions and is the unit of the transition-composition monoid. diff --git a/test/Dtmc/Analysis/AbsorptionSpec.hs b/test/Dtmc/Analysis/AbsorptionSpec.hs --- a/test/Dtmc/Analysis/AbsorptionSpec.hs +++ b/test/Dtmc/Analysis/AbsorptionSpec.hs @@ -1,7 +1,6 @@ {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveAnyClass #-} {-# LANGUAGE DeriveGeneric #-} -{-# LANGUAGE TypeApplications #-} module Dtmc.Analysis.AbsorptionSpec ( spec, @@ -72,8 +71,35 @@ either (error . show) id $ fromRows (chunksOf 2 [0, 1, 1, 0]) +illConditionedTransientBlock :: TransitionMatrix (Finite 4) +illConditionedTransientBlock = + either (error . show) id $ + fromRows + ( chunksOf + 4 + [ 1 - epsilon + , 0 + , epsilon + , 0 + , 0 + , 0 + , 0 + , 1 + , 0 + , 0 + , 1 + , 0 + , 0 + , 0 + , 0 + , 1 + ] + ) + where + epsilon = 1e-14 + closeTo :: Double -> Double -> Bool -closeTo expected actual = approxEq testTolerance expected actual +closeTo = approxEq testTolerance finiteCloseTo :: Double -> E.Expectation -> Bool finiteCloseTo expected (E.FiniteExpectation x) = closeTo expected x @@ -116,6 +142,12 @@ Absorption.probabilityGivenInitialState chain C C `shouldBe` Right 1 Absorption.probabilityGivenInitialState chain D C `shouldBe` Right 0 + it "does not force an ill-conditioned transient solve at a recurrent state" $ do + Absorption.probabilityGivenInitialState illConditionedTransientBlock 2 2 + `shouldBe` Right 1 + Absorption.probabilityGivenInitialState illConditionedTransientBlock 2 3 + `shouldBe` Right 0 + it "is exactly zero for a transient target" $ Absorption.probabilityGivenInitialState chain A B `shouldBe` Right 0 @@ -131,6 +163,35 @@ Hitting.eventualProbabilityGivenInitialState chain [C, D] A `shouldSatisfy` rightCloseTo (toC + toD) other -> expectationFailure ("solve failed: " <> show other) + + describe "probabilityMatrix" $ do + it "returns the complete closed-form absorption table" $ + case Absorption.probabilityMatrix chain of + Left err -> expectationFailure ("solve failed: " <> show err) + Right (transient, recurrent, rows) -> do + transient `shouldBe` [A, B] + recurrent `shouldBe` [C, D] + concat rows + `shouldSatisfy` ( and + . zipWith + closeTo + [17 / 20, 3 / 20, 11 / 20, 9 / 20] + ) + + it "returns empty rows when no state is transient" $ + Absorption.probabilityMatrix twoCycle + `shouldBe` Right ([], [False, True], []) + + it "agrees with every scalar absorption probability" $ + case Absorption.probabilityMatrix chain of + Left err -> expectationFailure ("solve failed: " <> show err) + Right (transient, recurrent, rows) -> + sequence_ + [ Absorption.probabilityGivenInitialState chain target initial + `shouldSatisfy` rightCloseTo expected + | (initial, row) <- zip transient rows + , (target, expected) <- zip recurrent row + ] describe "expectationByState" $ do it "matches the closed form of the notes" $ diff --git a/test/Dtmc/Analysis/CanonicalDifferentialSpec.hs b/test/Dtmc/Analysis/CanonicalDifferentialSpec.hs --- a/test/Dtmc/Analysis/CanonicalDifferentialSpec.hs +++ b/test/Dtmc/Analysis/CanonicalDifferentialSpec.hs @@ -1,5 +1,4 @@ {-# LANGUAGE DataKinds #-} -{-# LANGUAGE TypeApplications #-} module Dtmc.Analysis.CanonicalDifferentialSpec ( spec, @@ -161,7 +160,7 @@ and [ let law = Oracle.hittingLaw 4 matrix target source exact = known (Oracle.lawProbability (EqualTo time) law) - dense = (hitProbabilityByState (EqualTo time) matrix [2]) + dense = hitProbabilityByState (EqualTo time) matrix [2] in close (Hit.probabilityGivenInitialState (EqualTo time) matrix target source) exact && close (dense !! fromIntegral source) exact | source <- finites @@ -170,7 +169,7 @@ && and [ let law = Oracle.hittingLaw 4 matrix target source bounded = known (Oracle.lawProbability (LessThan bound) law) - dense = (hitProbabilityByState (LessThan bound) matrix [2]) + dense = hitProbabilityByState (LessThan bound) matrix [2] in close (Hit.probabilityGivenInitialState (LessThan bound) matrix target source) bounded @@ -182,7 +181,7 @@ and [ let law = Oracle.returnLaw 4 matrix source exact = known (Oracle.lawProbability (EqualTo time) law) - dense = (returnProbabilityByState (EqualTo time) matrix) + dense = returnProbabilityByState (EqualTo time) matrix in close (Return.probabilityGivenInitialState (EqualTo time) matrix source) exact && close (dense !! fromIntegral source) exact | source <- finites @@ -191,7 +190,7 @@ && and [ let law = Oracle.returnLaw 4 matrix source bounded = known (Oracle.lawProbability (LessThan bound) law) - dense = (returnProbabilityByState (LessThan bound) matrix) + dense = returnProbabilityByState (LessThan bound) matrix in close (Return.probabilityGivenInitialState (LessThan bound) matrix source) bounded @@ -263,7 +262,7 @@ case hitEventualProbabilityByState terminalChain [1] of Left _ -> False Right dense -> - and (zipWith close (dense) hitValues) + and (zipWith close dense hitValues) && and [ rightClose expected (Hit.eventualProbabilityGivenInitialState terminalChain [1] state) | (state, expected) <- zip states hitValues @@ -281,7 +280,7 @@ case hitRaceProbabilityByState terminalChain [1] [2] of Left _ -> False Right dense -> - and (zipWith close (dense) raceValues) + and (zipWith close dense raceValues) && and [ rightClose expected @@ -305,7 +304,7 @@ case returnEventualProbabilityByState terminalChain of Left _ -> False Right dense -> - and (zipWith close (dense) returnValues) + and (zipWith close dense returnValues) && and [ rightClose expected (Return.eventualProbabilityGivenInitialState terminalChain state) | (state, expected) <- zip states returnValues @@ -373,5 +372,6 @@ Right matrix -> property (finiteAndBoundedChecks matrix) describe "canonical infinite-horizon differential baseline" $ do - it "all eventual, race, expectation, and total-visit queries match a completed path law" $ + it + "all eventual, race, expectation, and total-visit queries match a completed path law" terminalChecks diff --git a/test/Dtmc/Analysis/ClassificationSpec.hs b/test/Dtmc/Analysis/ClassificationSpec.hs --- a/test/Dtmc/Analysis/ClassificationSpec.hs +++ b/test/Dtmc/Analysis/ClassificationSpec.hs @@ -256,7 +256,7 @@ powers = take bound (drop 1 (iterate (boolMul s) (boolIdentity dim))) returns = [k | (k, m) <- zip [1 :: Int ..] powers, (m !! i) !! i] -classesAsInts :: (KnownNat n) => TransitionMatrix (Finite n) -> [[Integer]] +classesAsInts :: TransitionMatrix (Finite n) -> [[Integer]] classesAsInts = map (map getFinite . classMembers) . communicatingClasses cyclicClassesAsInts :: (KnownNat n) => TransitionMatrix (Finite n) -> Maybe [[Integer]] diff --git a/test/Dtmc/Analysis/EventSpec.hs b/test/Dtmc/Analysis/EventSpec.hs --- a/test/Dtmc/Analysis/EventSpec.hs +++ b/test/Dtmc/Analysis/EventSpec.hs @@ -66,12 +66,10 @@ let threshold = asNatural rawThreshold value = asNatural rawValue in property $ - and - [ matches (GreaterThan threshold) value - /= matches (AtMost threshold) value - , matches (AtLeast threshold) value + matches (GreaterThan threshold) value + /= matches (AtMost threshold) value + && matches (AtLeast threshold) value /= matches (LessThan threshold) value - ] describe "includesInfiniteOutcome" $ do it "includes infinity exactly in upper-tail events" $ do diff --git a/test/Dtmc/Analysis/FiniteTimeCanonicalSpec.hs b/test/Dtmc/Analysis/FiniteTimeCanonicalSpec.hs --- a/test/Dtmc/Analysis/FiniteTimeCanonicalSpec.hs +++ b/test/Dtmc/Analysis/FiniteTimeCanonicalSpec.hs @@ -1,5 +1,4 @@ {-# LANGUAGE DataKinds #-} -{-# LANGUAGE TypeApplications #-} module Dtmc.Analysis.FiniteTimeCanonicalSpec ( spec, diff --git a/test/Dtmc/Analysis/HittingTimeCanonicalSpec.hs b/test/Dtmc/Analysis/HittingTimeCanonicalSpec.hs --- a/test/Dtmc/Analysis/HittingTimeCanonicalSpec.hs +++ b/test/Dtmc/Analysis/HittingTimeCanonicalSpec.hs @@ -1,5 +1,4 @@ {-# LANGUAGE DataKinds #-} -{-# LANGUAGE TypeApplications #-} module Dtmc.Analysis.HittingTimeCanonicalSpec ( spec, @@ -115,7 +114,7 @@ [ let law = Oracle.hittingLaw 4 matrix isTarget initial oracle = known (Oracle.lawProbability event law) scalar = Hit.probabilityGivenInitialState event matrix isTarget initial - dense = (hitProbabilityByState event matrix [2]) + dense = hitProbabilityByState event matrix [2] in close scalar oracle && close (dense !! fromIntegral initial) oracle | initial <- finites @@ -138,19 +137,19 @@ Hit.probabilityGivenInitialState (AtLeast 0) terminalChain target 0 `shouldBe` 1 Hit.probabilityGivenInitialState (AtLeast 1) terminalChain target 0 `shouldBe` 1 Hit.probabilityGivenInitialState (AtLeast 2) terminalChain target 0 `shouldBe` 0.5 - (hitProbabilityByState (GreaterThan 1) terminalChain [1]) + hitProbabilityByState (GreaterThan 1) terminalChain [1] `shouldBe` [0.5, 0, 1] - (hitProbabilityByState (AtMost 1) terminalChain [1]) + hitProbabilityByState (AtMost 1) terminalChain [1] `shouldBe` [0.5, 1, 0] it "keeps empty-target and time-zero boundaries structural" $ do - (hitProbabilityByState (EqualTo 3) terminalChain []) + hitProbabilityByState (EqualTo 3) terminalChain [] `shouldBe` [0, 0, 0] - (hitProbabilityByState (AtMost 3) terminalChain []) + hitProbabilityByState (AtMost 3) terminalChain [] `shouldBe` [0, 0, 0] - (hitProbabilityByState (GreaterThan 3) terminalChain []) + hitProbabilityByState (GreaterThan 3) terminalChain [] `shouldBe` [1, 1, 1] - (hitProbabilityByState (AtLeast 0) terminalChain [1]) + hitProbabilityByState (AtLeast 0) terminalChain [1] `shouldBe` [1, 1, 1] Hit.probabilityGivenInitialState (EqualTo 0) terminalChain (== 1) 1 `shouldBe` 1 Hit.probabilityGivenInitialState (GreaterThan 0) terminalChain (== 1) 1 `shouldBe` 0 diff --git a/test/Dtmc/Analysis/NamespaceCompileSpec.hs b/test/Dtmc/Analysis/NamespaceCompileSpec.hs --- a/test/Dtmc/Analysis/NamespaceCompileSpec.hs +++ b/test/Dtmc/Analysis/NamespaceCompileSpec.hs @@ -131,5 +131,7 @@ `shouldBe` Right (FiniteExpectation 0.5) Absorption.probability matrix 1 mixedInitial `shouldBe` Right 1 + Absorption.probabilityMatrix matrix + `shouldBe` Right ([0], [1], [[1]]) Absorption.expectation matrix mixedInitial `shouldBe` Right (FiniteExpectation 0.5) diff --git a/test/Dtmc/Analysis/ProbabilityOracle.hs b/test/Dtmc/Analysis/ProbabilityOracle.hs --- a/test/Dtmc/Analysis/ProbabilityOracle.hs +++ b/test/Dtmc/Analysis/ProbabilityOracle.hs @@ -17,6 +17,7 @@ getFinite, ) import Data.List ( + elemIndex, findIndex, ) import Data.Map.Strict ( @@ -178,7 +179,7 @@ where paths = weightedTrajectories horizon [(initial, 1)] matrix firstReturn path = - fromIntegral . (+ 1) <$> findIndex (== initial) (drop 1 path) + fromIntegral . (+ 1) <$> elemIndex initial (drop 1 path) visitLawBefore :: (FiniteState state) => diff --git a/test/Dtmc/Analysis/ReturnTimeCanonicalSpec.hs b/test/Dtmc/Analysis/ReturnTimeCanonicalSpec.hs --- a/test/Dtmc/Analysis/ReturnTimeCanonicalSpec.hs +++ b/test/Dtmc/Analysis/ReturnTimeCanonicalSpec.hs @@ -1,5 +1,4 @@ {-# LANGUAGE DataKinds #-} -{-# LANGUAGE TypeApplications #-} module Dtmc.Analysis.ReturnTimeCanonicalSpec ( spec, @@ -112,7 +111,7 @@ [ let law = Oracle.returnLaw 4 matrix initial oracle = known (Oracle.lawProbability event law) scalar = Return.probabilityGivenInitialState event matrix initial - dense = (returnProbabilityByState event matrix) + dense = returnProbabilityByState event matrix in close scalar oracle && close (dense !! fromIntegral initial) oracle | initial <- finites @@ -123,28 +122,28 @@ spec = do describe "canonical return probability" $ do it "enforces the time-zero exclusion exactly" $ do - (returnProbabilityByState (EqualTo 0) terminalChain) + returnProbabilityByState (EqualTo 0) terminalChain `shouldBe` [0, 0, 0] - (returnProbabilityByState (LessThan 1) terminalChain) + returnProbabilityByState (LessThan 1) terminalChain `shouldBe` [0, 0, 0] - (returnProbabilityByState (AtMost 0) terminalChain) + returnProbabilityByState (AtMost 0) terminalChain `shouldBe` [0, 0, 0] - (returnProbabilityByState (GreaterThan 0) terminalChain) + returnProbabilityByState (GreaterThan 0) terminalChain `shouldBe` [1, 1, 1] - (returnProbabilityByState (AtLeast 0) terminalChain) + returnProbabilityByState (AtLeast 0) terminalChain `shouldBe` [1, 1, 1] - (returnProbabilityByState (AtLeast 1) terminalChain) + returnProbabilityByState (AtLeast 1) terminalChain `shouldBe` [1, 1, 1] it "implements every relation and carries non-return mass in upper tails" $ do Return.probabilityGivenInitialState (EqualTo 1) terminalChain 2 `shouldBe` 1 Return.probabilityGivenInitialState (AtMost 1) terminalChain 2 `shouldBe` 1 Return.probabilityGivenInitialState (GreaterThan 1) terminalChain 2 `shouldBe` 0 - (returnProbabilityByState (AtMost 1) terminalChain) + returnProbabilityByState (AtMost 1) terminalChain `shouldBe` [0, 0, 1] - (returnProbabilityByState (GreaterThan 1) terminalChain) + returnProbabilityByState (GreaterThan 1) terminalChain `shouldBe` [1, 1, 0] - (returnProbabilityByState (AtLeast 2) terminalChain) + returnProbabilityByState (AtLeast 2) terminalChain `shouldBe` [1, 1, 0] it "preserves locally finite kernels and tiny survivor mass directly" $ do diff --git a/test/Dtmc/Analysis/TimeSpecSupport.hs b/test/Dtmc/Analysis/TimeSpecSupport.hs --- a/test/Dtmc/Analysis/TimeSpecSupport.hs +++ b/test/Dtmc/Analysis/TimeSpecSupport.hs @@ -320,7 +320,7 @@ Right result -> sequence_ [ x `shouldSatisfy` closeTo (1 - fromIntegral i / 4) - | (i, x) <- zip [0 :: Int ..] (result) + | (i, x) <- zip [0 :: Int ..] result ] it "solves the oscillator race to a single absorbing state" $ do @@ -329,7 +329,7 @@ Right result -> sequence_ [ x `shouldSatisfy` closeTo v - | (x, v) <- zip (result) [2 / 3, 1 / 3, 1, 0] + | (x, v) <- zip result [2 / 3, 1 / 3, 1, 0] ] it "is all zero for an empty target" $ @@ -355,7 +355,7 @@ (x >= -testTolerance && x <= 1 + testTolerance) | otherwise -> x === 0 | (i, x) <- - zip (finites :: [Finite 4]) (result) + zip (finites :: [Finite 4]) result ] prop "satisfies the first-step equations off the target (random @4)" $ @@ -371,42 +371,42 @@ in conjoin [ property (closeTo hi pi_) | (i, hi, pi_) <- - zip3 (finites :: [Finite 4]) (h) pushed + zip3 (finites :: [Finite 4]) h pushed , i /= 0 ] describe "bounded hitting times" $ do it "returns an empty result for the empty chain" $ - ((hitProbabilityByState . LessThan) 3 (identity @(Finite 0)) []) + (hitProbabilityByState . LessThan) 3 (identity @(Finite 0)) [] `shouldBe` [] it "places all time-zero mass on the target" $ - ((hitProbabilityByState . EqualTo) 0 oscillator [2]) + (hitProbabilityByState . EqualTo) 0 oscillator [2] `shouldBe` [0, 0, 1, 0] it "gives zero exact-time mass for an empty target" $ - ((hitProbabilityByState . EqualTo) 5 oscillator []) + (hitProbabilityByState . EqualTo) 5 oscillator [] `shouldBe` [0, 0, 0, 0] it "matches a one-step gambler's-ruin hit" $ - ((hitProbabilityByState . EqualTo) 1 (gambler 0.5) [0]) + (hitProbabilityByState . EqualTo) 1 (gambler 0.5) [0] `shouldBe` [0, 0.5, 0, 0, 0] it "uses a strict time bound" $ do - ((hitProbabilityByState . LessThan) 0 oscillator [2]) + (hitProbabilityByState . LessThan) 0 oscillator [2] `shouldBe` [0, 0, 0, 0] - ((hitProbabilityByState . LessThan) 1 oscillator [2]) + (hitProbabilityByState . LessThan) 1 oscillator [2] `shouldBe` [0, 0, 1, 0] (Hit.probabilityGivenInitialState . LessThan) 2 (gambler 0.5) (== 0) 1 `shouldSatisfy` closeTo 0.5 it "ignores duplicate and reordered targets" $ - ((hitProbabilityByState . LessThan) 4 oscillator [2, 3, 2]) - `shouldBe` ((hitProbabilityByState . LessThan) 4 oscillator [3, 2]) + (hitProbabilityByState . LessThan) 4 oscillator [2, 3, 2] + `shouldBe` (hitProbabilityByState . LessThan) 4 oscillator [3, 2] it "single-state queries look up the all-state results" $ do - let exact = ((hitProbabilityByState . EqualTo) 3 oscillator [2]) - bounded = ((hitProbabilityByState . LessThan) 4 oscillator [2]) + let exact = (hitProbabilityByState . EqualTo) 3 oscillator [2] + bounded = (hitProbabilityByState . LessThan) 4 oscillator [2] sequence_ [ (Hit.probabilityGivenInitialState . EqualTo) 3 oscillator (== 2) i `shouldSatisfy` closeTo exactAt @@ -464,11 +464,10 @@ `shouldBe` Right 0 it "gives all zeros for identical successful and competing sets" $ - ( hitRaceProbabilityByState + hitRaceProbabilityByState oscillator [2, 3] [2, 3] - ) `shouldBe` Right (replicate 4 0) it "gives all zeros for an empty successful set" $ @@ -487,7 +486,7 @@ (Right before, Right plain) -> sequence_ [ x `shouldSatisfy` closeTo y - | (x, y) <- zip (before) (plain) + | (x, y) <- zip before plain ] it "is exactly zero when the successful set is unreachable" $ @@ -514,7 +513,7 @@ (Right withDuplicates, Right once) -> sequence_ [ x `shouldSatisfy` closeTo y - | (x, y) <- zip (withDuplicates) (once) + | (x, y) <- zip withDuplicates once ] it "ignores target order" $ do @@ -532,7 +531,7 @@ (Right reordered, Right ordered) -> sequence_ [ x `shouldSatisfy` closeTo y - | (x, y) <- zip (reordered) (ordered) + | (x, y) <- zip reordered ordered ] it "single-state lookups match the all-state vector" $ @@ -550,7 +549,7 @@ i `shouldSatisfy` either (const False) (closeTo x) | (i, x) <- - zip (finites :: [Finite 4]) (result) + zip (finites :: [Finite 4]) result ] it "solves the oscillator race against a competing absorber" $ do @@ -559,7 +558,7 @@ Right result -> sequence_ [ x `shouldSatisfy` closeTo v - | (x, v) <- zip (result) [2 / 3, 1 / 3, 1, 0] + | (x, v) <- zip result [2 / 3, 1 / 3, 1, 0] ] it "matches a hand-computed symmetric race (gambler p = 0.5)" $ do @@ -568,7 +567,7 @@ Right result -> sequence_ [ x `shouldSatisfy` closeTo (fromIntegral i / 4) - | (i, x) <- zip [0 :: Int ..] (result) + | (i, x) <- zip [0 :: Int ..] result ] it "disjoint races sum to one when the union is hit almost surely" $ @@ -581,7 +580,7 @@ (Right wins, Right losses) -> sequence_ [ (x + y) `shouldSatisfy` closeTo 1 - | (x, y) <- zip (wins) (losses) + | (x, y) <- zip wins losses ] | pp <- [0.3, 0.5, 0.7] , let g = gambler pp @@ -676,38 +675,38 @@ returnTimeSpec = do describe "bounded first-return times" $ do it "returns an empty result for the empty chain" $ - ((returnProbabilityByState . LessThan) 3 (identity @(Finite 0))) + (returnProbabilityByState . LessThan) 3 (identity @(Finite 0)) `shouldBe` [] it "has no return mass at time zero" $ - ((returnProbabilityByState . EqualTo) 0 oscillator) + (returnProbabilityByState . EqualTo) 0 oscillator `shouldBe` [0, 0, 0, 0] it "uses the transition diagonal at time one" $ - ((returnProbabilityByState . EqualTo) 1 nonUniformRecurrent) + (returnProbabilityByState . EqualTo) 1 nonUniformRecurrent `shouldBe` [0.9, 0.6] it "counts only the first return" $ do - ((returnProbabilityByState . EqualTo) 1 oscillator) + (returnProbabilityByState . EqualTo) 1 oscillator `shouldBe` [0, 0, 1, 1] - ((returnProbabilityByState . EqualTo) 2 oscillator) + (returnProbabilityByState . EqualTo) 2 oscillator `shouldBe` [0.25, 0.25, 0, 0] - ((returnProbabilityByState . EqualTo) 2 twoCycle) + (returnProbabilityByState . EqualTo) 2 twoCycle `shouldBe` [1, 1] it "uses a strict time bound" $ do - ((returnProbabilityByState . LessThan) 0 oscillator) + (returnProbabilityByState . LessThan) 0 oscillator `shouldBe` [0, 0, 0, 0] - ((returnProbabilityByState . LessThan) 1 oscillator) + (returnProbabilityByState . LessThan) 1 oscillator `shouldBe` [0, 0, 0, 0] - ((returnProbabilityByState . LessThan) 2 oscillator) + (returnProbabilityByState . LessThan) 2 oscillator `shouldBe` [0, 0, 1, 1] - ((returnProbabilityByState . LessThan) 3 twoCycle) + (returnProbabilityByState . LessThan) 3 twoCycle `shouldBe` [1, 1] it "single-state queries look up the all-state results" $ do - let exact = ((returnProbabilityByState . EqualTo) 3 oscillator) - bounded = ((returnProbabilityByState . LessThan) 4 oscillator) + let exact = (returnProbabilityByState . EqualTo) 3 oscillator + bounded = (returnProbabilityByState . LessThan) 4 oscillator sequence_ [ (Return.probabilityGivenInitialState . EqualTo) 3 oscillator i `shouldSatisfy` closeTo exactAt @@ -788,7 +787,7 @@ ( zipWith (*) row - (hits) + hits ) in counterexample (show (i, f, firstStep)) @@ -797,7 +796,7 @@ zip3 (finites :: [Finite 4]) rows - (returns) + returns ] it "is one for an absorbing state" $ @@ -934,7 +933,7 @@ `shouldSatisfy` either (const False) (closeTo 0.5) it "solves bounded hitting queries in named state order" $ - ((hitProbabilityByState . LessThan) 3 namedGambler [Won]) + (hitProbabilityByState . LessThan) 3 namedGambler [Won] `shouldBe` [0, 0, 0.25, 0.5, 1] it "solves named expected hitting and return times" $ do diff --git a/test/Dtmc/Analysis/VisitCountCanonicalSpec.hs b/test/Dtmc/Analysis/VisitCountCanonicalSpec.hs --- a/test/Dtmc/Analysis/VisitCountCanonicalSpec.hs +++ b/test/Dtmc/Analysis/VisitCountCanonicalSpec.hs @@ -1,5 +1,3 @@ -{-# LANGUAGE TypeApplications #-} - module Dtmc.Analysis.VisitCountCanonicalSpec ( spec, ) where @@ -143,7 +141,7 @@ generatedTotalChecks matrix = and [ let scalar = checked (Visit.totalProbabilityGivenInitialState event matrix 0 initial) - dense = (checked (visitTotalProbabilityByState event matrix 0)) + dense = checked (visitTotalProbabilityByState event matrix 0) in close (dense !! fromIntegral initial) scalar && scalar >= negate testTolerance && scalar <= 1 + testTolerance diff --git a/test/Dtmc/Analysis/VisitCountSpec.hs b/test/Dtmc/Analysis/VisitCountSpec.hs --- a/test/Dtmc/Analysis/VisitCountSpec.hs +++ b/test/Dtmc/Analysis/VisitCountSpec.hs @@ -1,5 +1,3 @@ -{-# LANGUAGE TypeApplications #-} - module Dtmc.Analysis.VisitCountSpec ( spec, ) where @@ -147,7 +145,7 @@ describe "totalProbabilityByState" $ do it "matches the geometric law for a transient target" $ do let probabilities count = - (checked ((visitTotalProbabilityByState . EqualTo) count transientVisitChain 0)) + checked ((visitTotalProbabilityByState . EqualTo) count transientVisitChain 0) sequence_ [ actual `shouldSatisfy` closeTo expected | (actual, expected) <- @@ -163,7 +161,7 @@ | (actual, expected) <- zip (probabilities 3) [3 / 64, 3 / 128, 0] ] - (checked (visitInfiniteProbabilityByState transientVisitChain 0)) + checked (visitInfiniteProbabilityByState transientVisitChain 0) `shouldBe` [0, 0, 0] it "puts all positive recurrent-target mass at infinity" $ do @@ -173,14 +171,14 @@ [ actual `shouldSatisfy` closeTo expected | (actual, expected) <- zip - ((checked (visitInfiniteProbabilityByState recurrentVisitChain 2))) + (checked (visitInfiniteProbabilityByState recurrentVisitChain 2)) [2 / 3, 1 / 3, 1, 0] ] sequence_ [ actual `shouldSatisfy` closeTo expected | (actual, expected) <- zip - ((checked ((visitTotalProbabilityByState . EqualTo) 0 recurrentVisitChain 2))) + (checked ((visitTotalProbabilityByState . EqualTo) 0 recurrentVisitChain 2)) [1 / 3, 2 / 3, 0, 1] ] @@ -205,7 +203,7 @@ [ (Visit.totalProbabilityGivenInitialState . EqualTo) count matrix 0 initial === Right probability | (initial, probability) <- - zip (finites :: [Finite 3]) (probabilities) + zip (finites :: [Finite 3]) probabilities ] | count <- [0, 1, 3] ] @@ -216,7 +214,7 @@ [ Visit.infiniteProbabilityGivenInitialState matrix 0 initial === Right probability | (initial, probability) <- - zip (finites :: [Finite 3]) (probabilities) + zip (finites :: [Finite 3]) probabilities ] ] diff --git a/test/Dtmc/SimulationSpec.hs b/test/Dtmc/SimulationSpec.hs --- a/test/Dtmc/SimulationSpec.hs +++ b/test/Dtmc/SimulationSpec.hs @@ -18,14 +18,15 @@ Distribution (..), ) import Dtmc.Distribution.Map ( - pointMass, fromDistribution, + pointMass, ) import Dtmc.Distribution.Vector qualified as Vector import Dtmc.Simulation ( SimulationError (..), sample, simulate, + simulateMatrix, step, ) import Dtmc.State (FiniteState) @@ -70,9 +71,7 @@ distributionWeights (UncheckedDistribution entries) = entries checkedSimulation :: (Monad m) => m (Either SimulationError value) -> m value -checkedSimulation action = do - result <- action - pure (either (error . show) id result) +checkedSimulation action = either (error . show) id <$> action cyclicThree :: TransitionMatrix (Finite 3) cyclicThree = @@ -98,6 +97,15 @@ fromRows @NamedSample (chunksOf 3 [0, 1, 0, 0, 0, 1, 1, 0, 0]) +iidThree :: TransitionMatrix (Finite 3) +iidThree = + either (error . show) id $ + fromRows + [ [0.2, 0.3, 0.5] + , [0.2, 0.3, 0.5] + , [0.2, 0.3, 0.5] + ] + absorbingTwo :: TransitionMatrix (Finite 2) absorbingTwo = either (error . show) id $ @@ -181,6 +189,21 @@ after <- MWC.save generator pure (result, before == after) +zeroStepMatrixAndGeneratorState :: (Either SimulationError [Finite 3], Bool) +zeroStepMatrixAndGeneratorState = runST $ do + generator <- MWC.create + before <- MWC.save generator + result <- + simulateMatrix + 0 + ( error "zero-step matrix simulation evaluated its matrix" :: + TransitionMatrix (Finite 3) + ) + 0 + generator + after <- MWC.save generator + pure (result, before == after) + emptyKernel :: Kernel.TransitionKernel Int emptyKernel = Kernel.fromLaws @@ -285,3 +308,41 @@ simulate 3 emptyKernel 0 generator ) `shouldBe` Left EmptySupport + + describe "simulateMatrix" $ do + it "follows a deterministic matrix cycle" $ + let trajectory = runST $ do + generator <- MWC.create + checkedSimulation (simulateMatrix 4 cyclicThree 0 generator) + in trajectory `shouldBe` [0, 1, 2, 0, 1] + + it "supports named finite states" $ + let trajectory = runST $ do + generator <- MWC.create + checkedSimulation + (simulateMatrix 4 namedCyclicThree FirstSample generator) + in trajectory + `shouldBe` [ FirstSample + , SecondSample + , ThirdSample + , FirstSample + , SecondSample + ] + + it "samples a dense row with the expected frequencies" $ + let trajectory = runST $ do + generator <- MWC.create + checkedSimulation (simulateMatrix 20000 iidThree 0 generator) + observed :: Finite 3 -> Double + observed state = + fromIntegral (length (filter (== state) (drop 1 trajectory))) + / 20000 + in do + (abs (observed 0 - 0.2) < 0.02) `shouldBe` True + (abs (observed 1 - 0.3) < 0.02) `shouldBe` True + (abs (observed 2 - 0.5) < 0.02) `shouldBe` True + + it "does not inspect the matrix or advance the generator at zero steps" $ do + let (result, unchanged) = zeroStepMatrixAndGeneratorState + result `shouldBe` Right [0] + unchanged `shouldBe` True diff --git a/test/Dtmc/TestSupport.hs b/test/Dtmc/TestSupport.hs --- a/test/Dtmc/TestSupport.hs +++ b/test/Dtmc/TestSupport.hs @@ -1,5 +1,4 @@ {-# LANGUAGE ScopedTypeVariables #-} -{-# LANGUAGE TypeApplications #-} module Dtmc.TestSupport ( testTolerance, diff --git a/test/Dtmc/Transition/InterfaceSpec.hs b/test/Dtmc/Transition/InterfaceSpec.hs --- a/test/Dtmc/Transition/InterfaceSpec.hs +++ b/test/Dtmc/Transition/InterfaceSpec.hs @@ -1,5 +1,3 @@ -{-# LANGUAGE TypeApplications #-} - module Dtmc.Transition.InterfaceSpec ( spec, ) where @@ -18,6 +16,9 @@ chunksOf, genTransitionRows, ) +import Dtmc.Transition ( + Transition (..), + ) import Dtmc.Transition qualified as Transition import Dtmc.Transition.Kernel qualified as Kernel import Dtmc.Transition.Matrix ( @@ -43,6 +44,14 @@ checked :: (Show error) => Either error value -> value checked = either (error . show) id +data PublicCustomTransition = PublicCustomTransition + +-- A downstream instance needs to implement only the documented public +-- method; internal optimization hooks keep their library defaults. +instance Transition PublicCustomTransition where + type TransitionState PublicCustomTransition = Int + transitionLaw _ = DistributionMap.pointMass . (+ 1) + finiteChain :: TransitionMatrix (Finite 3) finiteChain = checked $ @@ -75,6 +84,11 @@ spec :: Spec spec = describe "Transition interface" $ do + it "keeps custom transition instances source-compatible" $ + Distribution.distributionWeights + (transitionLaw PublicCustomTransition 4) + `shouldBe` [(5, 1)] + it "exposes a matrix row as a finite-support transition law" $ Distribution.distributionWeights (Transition.transitionLaw finiteChain 1) `shouldBe` [(1, 0.2), (2, 0.8)]