monopoly-polysome 0.1.0__tar.gz

monopoly_polysome-0.1.0/.gitignore

@@ -0,0 +1,16 @@
+.coverage
+.development/
+.ipython/
+.jupyter*/
+.mplconfig/
+.pytest_cache/
+.ruff_cache/
+.venv/
+.ipynb_checkpoints/
+__pycache__/
+build/
+benchmark-results/
+dist/
+htmlcov/
+*.egg-info/
+*.py[cod]

monopoly_polysome-0.1.0/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## 0.1.0
+
+- Added validated three-fraction datasets and paired condition-by-fraction models.
+- Made within-fraction median-of-ratios normalization the default.
+- Added explicit polysome, monosome, and input contrasts with stable effect direction.
+- Added gene-level diagnostics, input fingerprints, and provenance sidecars.
+- Defined the shared-dispersion Wald model as a transparent working model.
+- Added a frozen, resumable simulation benchmark against R DESeq2, edgeR,
+  a log-ratio baseline, and FracFixR's native tests and fraction reconstruction.

monopoly_polysome-0.1.0/CITATION.cff

@@ -0,0 +1,12 @@
+cff-version: 1.2.0
+message: 'If you use Monopoly, please cite the software and associated manuscript.'
+title: 'Monopoly: paired differential analysis of polysome profiling RNA-seq data'
+type: software
+authors:
+  - family-names: 'DeGroat'
+    given-names: 'William'
+  - family-names: 'Kreimer'
+    given-names: 'Anat'
+version: 0.1.0
+license: MIT
+repository-code: 'https://github.com/WillDeGroat/monopoly'

monopoly_polysome-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,21 @@
+# Contributing
+
+Create an isolated Python 3.11 or later environment and install the development
+dependencies:
+
+```console
+python -m pip install -e ".[dev]"
+```
+
+Before submitting a change, run:
+
+```console
+python -m ruff check .
+python -m pytest --cov=monopoly
+python -m build
+```
+
+Public API changes require tests and corresponding updates to the README and method
+documentation. Statistical changes must define their estimand, assumptions, failure
+modes, and validation criteria before implementation. Do not promote a method based
+only on additional discoveries in one biological dataset.

monopoly_polysome-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 William DeGroat and Anat Kreimer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

monopoly_polysome-0.1.0/PKG-INFO

@@ -0,0 +1,188 @@
+Metadata-Version: 2.4
+Name: monopoly-polysome
+Version: 0.1.0
+Summary: Paired differential analysis of polysome profiling RNA-seq data.
+Project-URL: Repository, https://github.com/WillDeGroat/monopoly
+Project-URL: Documentation, https://github.com/WillDeGroat/monopoly#readme
+Project-URL: Changelog, https://github.com/WillDeGroat/monopoly/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/WillDeGroat/monopoly/issues
+Author: William DeGroat, Anat Kreimer
+License-Expression: MIT
+License-File: LICENSE
+Keywords: RNA-seq,bioinformatics,polysome profiling,translation
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.11
+Requires-Dist: formulaic<2,>=1.0
+Requires-Dist: numpy<3,>=1.26
+Requires-Dist: pandas<4,>=2.2
+Requires-Dist: pydeseq2<0.6,>=0.5.4
+Provides-Extra: dev
+Requires-Dist: build<2,>=1; extra == 'dev'
+Requires-Dist: pytest-cov<8,>=5; extra == 'dev'
+Requires-Dist: pytest<10,>=8; extra == 'dev'
+Requires-Dist: ruff<1,>=0.9; extra == 'dev'
+Requires-Dist: scipy<2,>=1.12; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Monopoly
+
+Monopoly is a Python package for paired differential analysis of input, monosome,
+and polysome RNA-seq count data. It estimates condition-associated changes in RNA
+distribution between experimental fractions while accounting for the matched
+participant design.
+
+Monopoly is designed for experiments in which every participant contributes all
+three fractions. It supports larger two-condition studies with unequal condition
+sizes; no study-specific sample size is hardcoded.
+
+## Install
+
+```console
+python -m pip install monopoly-polysome
+```
+
+The distribution is named `monopoly-polysome`; the Python import is `monopoly`.
+Python 3.11 or later is required.
+
+## Input
+
+Provide one participant-by-gene count matrix for each fraction and a participant
+metadata table containing a lowercase `condition` column. The three matrices must
+contain identical participant and gene identifiers.
+
+Counts must be finite, nonnegative whole numbers. For Salmon gene quantification,
+round `lengthScaledTPM` count-scale values once before constructing the dataset. Do
+not use TPM as counts. Filtering and transcript aggregation remain upstream analysis
+decisions; see the
+[data contract](https://github.com/WillDeGroat/monopoly/blob/main/docs/DATA_CONTRACT.md).
+
+## Workflow
+
+```python
+from monopoly import MonopolyDataset, MonopolyModel
+
+dataset = MonopolyDataset(
+    input = input_counts,
+    monosome = monosome_counts,
+    polysome = polysome_counts,
+    metadata = metadata,
+    gene_metadata = gene_metadata,
+)
+
+model = MonopolyModel(
+    dataset = dataset,
+    reference = 'Control',
+).fit(
+    normalization = 'fraction',
+)
+
+results = model.contrast('poly', 'mono')
+results.write('polyVsMono.tsv')
+```
+
+`poly` and `mono` are accepted contrast aliases for `polysome` and `monosome`.
+`input` is used without an alias. Version 0.1 requires exactly two conditions and
+infers the test condition as the level other than `reference`.
+
+A positive polysome-versus-monosome `log2FoldChange` means that the normalized
+polysome-to-monosome ratio is higher in the test condition than in the reference
+condition. `poly` versus `input` and `mono` versus `input` provide secondary
+decompositions.
+
+## Model
+
+Monopoly fits a negative-binomial generalized linear model with participant fixed
+effects, fraction effects, and condition-by-fraction interactions. Participant fixed
+effects make each contrast a within-participant fraction comparison. The released
+model uses one moderated dispersion per gene across fractions and asymptotic Wald
+tests through PyDESeq2.
+
+Fraction-wise median-of-ratios normalization is the default. It avoids treating
+input, monosome, and polysome libraries as one compositionally homogeneous source.
+Joint normalization remains available as an explicit sensitivity analysis:
+
+```python
+model.fit(normalization = 'joint')
+```
+
+The complete mathematical specification and assumptions are in
+[method specification](https://github.com/WillDeGroat/monopoly/blob/main/docs/METHODS.md).
+
+## Interpretation boundary
+
+Monopoly estimates relative redistribution among sequenced RNA pools. It does not
+measure absolute protein synthesis, absolute RNA allocation, or ribosome number per
+transcript. Monosome fractions may contain actively translated RNA and must not be
+described as untranslated RNA.
+
+The Wald test assumes that one moderated dispersion per gene adequately represents
+all modeled fractions. Strong fraction-specific mean-variance differences can
+invalidate that assumption. Small studies can still use Monopoly for effect
+estimation, ranking, diagnostics, and sensitivity analyses, but the package does not
+claim that gene-level false-discovery rates are calibrated merely because a model
+can be fit. Larger studies should also inspect fraction-specific variability and
+perform design-appropriate sensitivity analyses.
+
+Participant fixed effects leave each modeled library cell unique, so automatic
+Cook's filtering and outlier replacement are disabled. Cook's distances and explicit
+fit statuses remain available as diagnostics.
+
+## Results
+
+`MonopolyResults.table` contains stable camelCase columns:
+
+- `geneId` and optional `geneName`;
+- `baseMean`, `log2FoldChange`, and `log2FoldChangeSE`;
+- `statistic`, `pValue`, and `adjustedPValue`.
+
+`MonopolyResults.diagnostics` reports fit status, dispersion, maximum Cook's
+distance, Cook's-outlier status, and independent-filter status for every gene.
+`MonopolyResults.provenance` records package versions, input fingerprints, design,
+normalization, fit settings, contrast direction, and inferential scope.
+
+`results.write('polyVsMono.tsv')` writes three files:
+
+- `polyVsMono.tsv`;
+- `polyVsMono.diagnostics.tsv`; and
+- `polyVsMono.provenance.json`.
+
+Existing files are replaced.
+
+## Development
+
+```console
+python -m pip install -e ".[dev]"
+python -m ruff check .
+python -m pytest --cov=monopoly
+python -m build
+```
+
+The release test suite covers validation, design identifiability, normalization,
+contrast direction, invariance, diagnostics, output schemas, provenance, and package
+construction. See the
+[validation scope](https://github.com/WillDeGroat/monopoly/blob/main/docs/VALIDATION.md).
+
+The public simulation benchmark independently compares Monopoly with R DESeq2,
+edgeR, a log-ratio test, and FracFixR. Its estimands, frozen configurations, and run
+instructions are in the
+[benchmark README](https://github.com/WillDeGroat/monopoly/blob/main/benchmarks/README.md);
+the [HPC guide](https://github.com/WillDeGroat/monopoly/blob/main/docs/HPC_BENCHMARKS.md)
+covers publication-scale execution. FracFixR
+results are not presented as the same contrast when its native test targets a
+different single-fraction proportion.
+
+Monopoly is developed by William DeGroat and Anat Kreimer and released under the
+[MIT License](https://github.com/WillDeGroat/monopoly/blob/main/LICENSE).
+
+## Publication benchmark
+
+The complete frozen study benchmarks and the additional equal-dispersion run
+are linked from [benchmark results](benchmarks/results/README.md).
+See [release instructions](docs/RELEASING.md) for PyPI Trusted Publishing.

monopoly_polysome-0.1.0/README.md

@@ -0,0 +1,155 @@
+# Monopoly
+
+Monopoly is a Python package for paired differential analysis of input, monosome,
+and polysome RNA-seq count data. It estimates condition-associated changes in RNA
+distribution between experimental fractions while accounting for the matched
+participant design.
+
+Monopoly is designed for experiments in which every participant contributes all
+three fractions. It supports larger two-condition studies with unequal condition
+sizes; no study-specific sample size is hardcoded.
+
+## Install
+
+```console
+python -m pip install monopoly-polysome
+```
+
+The distribution is named `monopoly-polysome`; the Python import is `monopoly`.
+Python 3.11 or later is required.
+
+## Input
+
+Provide one participant-by-gene count matrix for each fraction and a participant
+metadata table containing a lowercase `condition` column. The three matrices must
+contain identical participant and gene identifiers.
+
+Counts must be finite, nonnegative whole numbers. For Salmon gene quantification,
+round `lengthScaledTPM` count-scale values once before constructing the dataset. Do
+not use TPM as counts. Filtering and transcript aggregation remain upstream analysis
+decisions; see the
+[data contract](https://github.com/WillDeGroat/monopoly/blob/main/docs/DATA_CONTRACT.md).
+
+## Workflow
+
+```python
+from monopoly import MonopolyDataset, MonopolyModel
+
+dataset = MonopolyDataset(
+    input = input_counts,
+    monosome = monosome_counts,
+    polysome = polysome_counts,
+    metadata = metadata,
+    gene_metadata = gene_metadata,
+)
+
+model = MonopolyModel(
+    dataset = dataset,
+    reference = 'Control',
+).fit(
+    normalization = 'fraction',
+)
+
+results = model.contrast('poly', 'mono')
+results.write('polyVsMono.tsv')
+```
+
+`poly` and `mono` are accepted contrast aliases for `polysome` and `monosome`.
+`input` is used without an alias. Version 0.1 requires exactly two conditions and
+infers the test condition as the level other than `reference`.
+
+A positive polysome-versus-monosome `log2FoldChange` means that the normalized
+polysome-to-monosome ratio is higher in the test condition than in the reference
+condition. `poly` versus `input` and `mono` versus `input` provide secondary
+decompositions.
+
+## Model
+
+Monopoly fits a negative-binomial generalized linear model with participant fixed
+effects, fraction effects, and condition-by-fraction interactions. Participant fixed
+effects make each contrast a within-participant fraction comparison. The released
+model uses one moderated dispersion per gene across fractions and asymptotic Wald
+tests through PyDESeq2.
+
+Fraction-wise median-of-ratios normalization is the default. It avoids treating
+input, monosome, and polysome libraries as one compositionally homogeneous source.
+Joint normalization remains available as an explicit sensitivity analysis:
+
+```python
+model.fit(normalization = 'joint')
+```
+
+The complete mathematical specification and assumptions are in
+[method specification](https://github.com/WillDeGroat/monopoly/blob/main/docs/METHODS.md).
+
+## Interpretation boundary
+
+Monopoly estimates relative redistribution among sequenced RNA pools. It does not
+measure absolute protein synthesis, absolute RNA allocation, or ribosome number per
+transcript. Monosome fractions may contain actively translated RNA and must not be
+described as untranslated RNA.
+
+The Wald test assumes that one moderated dispersion per gene adequately represents
+all modeled fractions. Strong fraction-specific mean-variance differences can
+invalidate that assumption. Small studies can still use Monopoly for effect
+estimation, ranking, diagnostics, and sensitivity analyses, but the package does not
+claim that gene-level false-discovery rates are calibrated merely because a model
+can be fit. Larger studies should also inspect fraction-specific variability and
+perform design-appropriate sensitivity analyses.
+
+Participant fixed effects leave each modeled library cell unique, so automatic
+Cook's filtering and outlier replacement are disabled. Cook's distances and explicit
+fit statuses remain available as diagnostics.
+
+## Results
+
+`MonopolyResults.table` contains stable camelCase columns:
+
+- `geneId` and optional `geneName`;
+- `baseMean`, `log2FoldChange`, and `log2FoldChangeSE`;
+- `statistic`, `pValue`, and `adjustedPValue`.
+
+`MonopolyResults.diagnostics` reports fit status, dispersion, maximum Cook's
+distance, Cook's-outlier status, and independent-filter status for every gene.
+`MonopolyResults.provenance` records package versions, input fingerprints, design,
+normalization, fit settings, contrast direction, and inferential scope.
+
+`results.write('polyVsMono.tsv')` writes three files:
+
+- `polyVsMono.tsv`;
+- `polyVsMono.diagnostics.tsv`; and
+- `polyVsMono.provenance.json`.
+
+Existing files are replaced.
+
+## Development
+
+```console
+python -m pip install -e ".[dev]"
+python -m ruff check .
+python -m pytest --cov=monopoly
+python -m build
+```
+
+The release test suite covers validation, design identifiability, normalization,
+contrast direction, invariance, diagnostics, output schemas, provenance, and package
+construction. See the
+[validation scope](https://github.com/WillDeGroat/monopoly/blob/main/docs/VALIDATION.md).
+
+The public simulation benchmark independently compares Monopoly with R DESeq2,
+edgeR, a log-ratio test, and FracFixR. Its estimands, frozen configurations, and run
+instructions are in the
+[benchmark README](https://github.com/WillDeGroat/monopoly/blob/main/benchmarks/README.md);
+the [HPC guide](https://github.com/WillDeGroat/monopoly/blob/main/docs/HPC_BENCHMARKS.md)
+covers publication-scale execution. FracFixR
+results are not presented as the same contrast when its native test targets a
+different single-fraction proportion.
+
+Monopoly is developed by William DeGroat and Anat Kreimer and released under the
+[MIT License](https://github.com/WillDeGroat/monopoly/blob/main/LICENSE).
+
+## Publication benchmark
+
+The complete frozen study benchmarks and the additional equal-dispersion run
+are linked from [benchmark results](benchmarks/results/README.md).
+See [release instructions](docs/RELEASING.md) for PyPI Trusted Publishing.

monopoly_polysome-0.1.0/STYLE.md

@@ -0,0 +1,45 @@
+# Monopoly style
+
+Monopoly should remain small, explicit, and unsurprising.
+
+Scientific terminology and assumptions are defined in `docs/METHODS.md`.
+
+## Design
+
+- Keep the public workflow centered on `MonopolyDataset`, `MonopolyModel`, and
+  `MonopolyResults`.
+- Prefer plain functions to inheritance, registries, factories, or plugin systems.
+- Add an abstraction only when it removes repeated behavior that already exists.
+- Use established numerical libraries whenever they can express the required method.
+- Use PyDESeq2 for negative-binomial estimation and established scientific
+  libraries for numerical work.
+- Validate at public boundaries. Internal functions may rely on validated inputs.
+- Never guess identifiers, silently remove observations, or mutate user objects.
+
+## Source
+
+- Use single-quoted strings. Docstrings use triple double quotes.
+- Limit lines to 88 characters.
+- Include spaces around keyword and default assignments.
+- Use concise one-line docstrings ending in periods for public APIs.
+- Use descriptive phrases for classes and imperative sentences for functions and
+  methods.
+- Add comments only when they explain scientific or non-obvious algorithmic reasoning.
+- Use `snake_case` internally and camelCase in exported scientific tables.
+- Use Ruff for linting and line-length enforcement. Format manually because standard
+  Python formatters remove the approved spaces around keyword assignments.
+
+## Errors
+
+- Raise a dedicated Monopoly exception with an actionable message.
+- Stop for invalid experiments or global model failures.
+- Preserve valid genome-wide fits when isolated genes fail, and report those failures
+  through diagnostics.
+
+## Tests
+
+- Test public contracts, scientific invariants, and failure modes.
+- Do not reproduce dependency test suites or preserve tests for rejected methods.
+- Use fixed random seeds only for deterministic numerical contract tests.
+- A successful test suite establishes implementation behavior, not universal
+  statistical calibration.

monopoly_polysome-0.1.0/benchmarks/README.md

@@ -0,0 +1,73 @@
+# Monopoly benchmark
+
+This benchmark evaluates the released three-pool model against independently
+generated truth. It is not a search for settings that maximize discoveries.
+
+## Methods
+
+- `monopoly`: fraction-wise median-ratio normalization and the released PyDESeq2
+  participant-by-fraction interaction model.
+- `deseq2`: an independent R implementation of the same design and normalization.
+  This is a numerical reference, not a method Monopoly is expected to outperform.
+- `edgeR`: the corresponding robust quasi-likelihood interaction model with
+  fraction-wise TMM normalization.
+- `ratioWelch`: a deliberately simple pseudocount log-ratio followed by a Welch
+  test. It represents a common analysis that does not model count uncertainty.
+- `fracfixr`: FracFixR 1.1.0 fraction reconstruction followed by its native GLM,
+  Logit, and beta-binomial Wald tests.
+
+Monopoly, DESeq2, edgeR, and `ratioWelch` target the condition difference in the
+log2 polysome-to-monosome ratio. FracFixR's Logit and Wald tests target the odds of
+one reconstructed fraction against the remainder. Its GLM returns a log2 ratio of
+mean reconstructed proportions while testing a binomial condition coefficient.
+All are reported under separate estimands. FracFixR fraction-weight recovery is
+evaluated in a separate table.
+
+## Run
+
+Install Monopoly with its development dependencies, then install the frozen R
+comparators:
+
+```console
+python -m pip install -e ".[dev]"
+Rscript benchmarks/r/install.R
+```
+
+Run the three-replicate software smoke test:
+
+```console
+python -m benchmarks.run benchmarks/configs/smoke.json benchmark-results/smoke \
+    --rscript Rscript --workers 1
+```
+
+`preflight.json` is a small scientific diagnostic. The two `publication_*.json`
+files contain the larger count-model and FracFixR grids. They are separate because
+FracFixR fits gene-wise models for a related but non-identical estimand and is much
+more computationally expensive. Run the smoke test and preflight locally before
+submitting either publication grid. See the
+[HPC walkthrough](../docs/HPC_BENCHMARKS.md) for a reproducible Slurm workflow.
+
+Runs are resumable. A result directory cannot be resumed after its configuration,
+method set, or benchmark source changes. Each run records seeds, configurations,
+software versions, simulation hashes, result hashes, failures, and runtime.
+The frozen R versions in `r/requirements.tsv` are enforced before any replicate is
+run. Completed replicate parts are written atomically, and progress is printed at
+approximately one-percent intervals. A missing or empty R result is retried once.
+If a replicate still fails, the runner reports its scenario and replicate, retains
+all other completed parts, and exits after the remaining submitted work finishes.
+Resume an interrupted run with the identical command and output directory. Never
+run multiple benchmark processes against the same output directory.
+
+## Outputs
+
+- `manifest.json`: run identity, environment, hashes, and completion state.
+- `seedManifest.tsv`: one immutable configuration and seed per replicate.
+- `replicateResults.tsv`: operating characteristics for each method and estimand.
+- `metricSummary.tsv`: means and Monte Carlo standard errors across replicates.
+- `benchmarkAssessment.tsv`: prespecified pass/fail calibration checks.
+- `fractionRecovery.tsv`: FracFixR fraction-weight recovery metrics.
+- `parts/`: atomic replicate outputs used for resumption and auditing.
+
+The smoke and preflight configurations are engineering checks, not validation
+evidence. Publication claims must use the frozen publication grids and report every
+prespecified scenario, including failures.

monopoly_polysome-0.1.0/benchmarks/__init__.py

@@ -0,0 +1,2 @@
+"""Public benchmark utilities for Monopoly."""
+

monopoly_polysome-0.1.0/benchmarks/configs/preflight.json

@@ -0,0 +1,68 @@
+{
+  "alpha": 0.05,
+  "benchmarkId": "monopoly-preflight-2026-09",
+  "methods": [
+    "monopoly",
+    "ratioWelch",
+    "deseq2",
+    "edgeR",
+    "fracfixr"
+  ],
+  "minimumMean": 20,
+  "scenarios": [
+    {
+      "dispersionCorrelation": 1.0,
+      "dispersionLogSd": 0.5,
+      "fractionDispersions": [0.15, 0.15, 0.15],
+      "genes": 500,
+      "participantsPerCondition": 3,
+      "redistributedGenes": 0,
+      "replicates": 4,
+      "scenarioId": "equalNullN3",
+      "seedStart": 41107000,
+      "transcriptionGenes": 0
+    },
+    {
+      "dispersionCorrelation": 0.7,
+      "dispersionLogSd": 0.5,
+      "fractionDispersions": [0.05, 0.15, 0.5],
+      "genes": 500,
+      "participantsPerCondition": 3,
+      "redistributedGenes": 0,
+      "replicates": 4,
+      "scenarioId": "unequalNullN3",
+      "seedStart": 41108000,
+      "transcriptionGenes": 0
+    },
+    {
+      "dispersionCorrelation": 1.0,
+      "dispersionLogSd": 0.5,
+      "fractionDispersions": [0.15, 0.15, 0.15],
+      "genes": 500,
+      "participantsPerCondition": 3,
+      "redistributedGenes": 100,
+      "redistributionLog2Effect": 2,
+      "redistributionPositiveFraction": 0.5,
+      "replicates": 4,
+      "scenarioId": "equalEffect2N3",
+      "seedStart": 41109000,
+      "transcriptionGenes": 100,
+      "transcriptionLog2Effect": 1
+    },
+    {
+      "dispersionCorrelation": 0.7,
+      "dispersionLogSd": 0.5,
+      "fractionDispersions": [0.05, 0.15, 0.5],
+      "genes": 500,
+      "participantsPerCondition": 3,
+      "redistributedGenes": 100,
+      "redistributionLog2Effect": 2,
+      "redistributionPositiveFraction": 0.5,
+      "replicates": 4,
+      "scenarioId": "unequalEffect2N3",
+      "seedStart": 41110000,
+      "transcriptionGenes": 100,
+      "transcriptionLog2Effect": 1
+    }
+  ]
+}