Datasets:

Larrivhan
/

NeCast-simulations

"""Tests for the two places the simulated data measurably left the real data.
Both are train/test mismatches rather than bugs: training is self-consistent
either way, the loss falls either way, and arms compare either way.  They only
bite when the model is pointed at a real dataset, and by then they are hard to
attribute -- a recent effective size that reads high looks like a model
failure, and a long-range feature that stops working looks like an
architecture failure.
"""

from __future__ import annotations

import dataclasses

import numpy as np
import pytest

from simulator.config import (
    SOURCE_PROB_FIELDS,
    Config,
    apply_preset,
    validate_config,
)
from simulator.noise import add_false_variants, noise_params_for_sample


def _config(**overrides) -> Config:
    cfg = apply_preset(Config(preset="full_v01"))
    settings = {"seq_len": 1_000_000, "include_truth": True, "truth_fraction": 1.0}
    settings.update(overrides)
    cfg = dataclasses.replace(cfg, **settings)
    validate_config(cfg)
    return cfg


# --------------------------------------------------------------------------
# Invented sites
# --------------------------------------------------------------------------


def test_a_false_variant_is_carried_by_exactly_one_haplotype() -> None:
    """Which is what makes it a singleton, and what the channel is for.
    Two independent errors landing on one position are rare enough to ignore,
    so a manufactured site is carried once.
    """

    rng = np.random.default_rng(0)
    genotypes = np.zeros((10, 64), dtype=np.uint8)
    positions = np.linspace(0, 999_999, 10)
    grown, grown_positions, stats = add_false_variants(
        genotypes, positions, rng, 1_000_000, 1.0e-3
    )
    assert stats["false_variant_count"] > 0
    assert grown.shape[0] == genotypes.shape[0] + stats["false_variant_count"]
    added = grown.sum(axis=1)
    # The ten real rows are empty here, so every non-empty row is invented.
    assert set(np.unique(added)).issubset({0, 1})
    assert int((added == 1).sum()) == stats["false_variant_count"]
    # Positions stay sorted, because everything downstream indexes by position.
    assert np.all(np.diff(grown_positions) >= 0)


def test_the_channel_is_off_where_the_source_is_declared_clean() -> None:
    cfg = _config()
    clean = noise_params_for_sample(
        np.random.default_rng(0), cfg, "clean_constant_map"
    )
    assert clean["false_variant_rate_per_bp"] == 0.0
    noisy = noise_params_for_sample(
        np.random.default_rng(0), cfg, "custom_heterogeneous"
    )
    assert noisy["false_variant_rate_per_bp"] > 0.0


def test_the_false_singleton_share_spans_what_callsets_report() -> None:
    """The rate is a property of the calling pipeline, not of the population.
    A hard-filtered callset and a raw one differ by orders of magnitude, so the
    prior has to cover the range rather than pick a point -- and the row has to
    record which was drawn, so the effect can be conditioned on or ablated.
    """

    cfg = _config()
    shares = []
    for seed in range(400):
        drawn = noise_params_for_sample(
            np.random.default_rng(seed), cfg, "custom_heterogeneous"
        )
        rate = drawn["false_variant_rate_per_bp"]
        # About sixteen hundred singletons a megabase at a typical effective
        # size; the constant only sets the scale this test reads in.
        shares.append(rate * cfg.seq_len / 1_600.0)
    assert np.percentile(shares, 10) < 0.05, "no near-clean callset drawn"
    assert np.percentile(shares, 90) > 0.15, "no raw callset drawn"


def test_invented_sites_are_recorded_on_the_row() -> None:
    """Recorded, not hidden: an ablation needs to be able to find them."""

    import dataclasses as dc

    from simulator.sample import simulate_one
    from simulator.shards import _metadata_row

    cfg = _config()
    sample = simulate_one(
        (0, dc.asdict(cfg), {"rec_maps": {}, "mut_maps": {}}, 4_242)
    )
    row = _metadata_row(sample["metadata"])
    assert "false_variant_rate_per_bp" in row
    assert "false_variant_count" in row


# --------------------------------------------------------------------------
# Map error that survives averaging
# --------------------------------------------------------------------------


def _correlation_by_scale(cfg: Config, seeds: int = 40) -> dict[int, float]:
    from simulator.sample import simulate_one

    def rebin(pos, rate, edges):
        cumulative = np.concatenate(([0.0], np.cumsum(rate * np.diff(pos))))
        return np.diff(np.interp(edges, pos, cumulative)) / np.diff(edges)

    found: dict[int, list[float]] = {1_000: [], 10_000: [], 100_000: []}
    for seed in range(seeds):
        sample = simulate_one(
            (seed, dataclasses.asdict(cfg), {"rec_maps": {}, "mut_maps": {}}, 90_000 + seed)
        )
        true_pos = sample["true_rec_pos"]
        obs_pos = sample["obs_rec_pos"]
        if true_pos.size < 3 or obs_pos.size < 3:
            continue
        for scale in found:
            edges = np.arange(0, cfg.seq_len + scale, scale, dtype=float)
            truth = rebin(true_pos, sample["true_rec_rate"], edges)
            observed = rebin(obs_pos, sample["obs_rec_rate"], edges)
            usable = (truth > 0) & (observed > 0)
            if usable.sum() > 10:
                found[scale].append(
                    float(np.corrcoef(np.log(truth[usable]), np.log(observed[usable]))[0, 1])
                )
    return {scale: float(np.median(values)) for scale, values in found.items() if values}


def test_map_error_survives_being_averaged() -> None:
    """The property the per-cell draw could not have.
    Independent error cancels: with one lognormal per cell the map handed to
    the model correlated 0.720 with the truth at a kilobase and 0.984 at a
    hundred, against 0.687 and 0.890 for two real published maps of the same
    region.  Zoomed out our map was effectively perfect, so a model could learn
    to trust the coarse map completely -- true in training and false on real
    data, where the disagreement is regional and averaging does not remove it.
    The tolerances are loose because the target is a property of two particular
    real maps; what is pinned is that the error still exists at a hundred
    kilobases, which the previous draw could not deliver at any amplitude.
    """

    cfg = _config(seq_len=2_000_000)
    for field in SOURCE_PROB_FIELDS:
        setattr(cfg, field, 0.0)
    cfg.p_custom_hetero = 1.0
    validate_config(cfg)

    measured = _correlation_by_scale(cfg)
    assert measured[1_000] == pytest.approx(0.687, abs=0.12)
    assert measured[100_000] == pytest.approx(0.890, abs=0.10)
    # And the decisive one: averaging a hundredfold must not restore the truth.
    assert measured[100_000] < 0.95, "the coarse map is too good to be real"
    assert measured[100_000] > measured[1_000], "error must still shrink with scale"


def test_the_mutation_map_survives_its_own_observation_noise() -> None:
    """The defect this test exists for was invisible to every other one.
    Observation error used to be an absolute log-scale amplitude, and the two
    maps are not on the same scale: across a row a recombination map's log rate
    has a standard deviation near 0.5 and a mutation map's near 0.04.  One
    number cannot serve both.  At an absolute 0.25 the observed recombination
    map correlated 0.851 with the truth -- fine -- while the observed mutation
    map correlated 0.163 on synthetic maps and 0.108 on real slices, with the
    level off by 0.07 to 0.09 in log10.  That is not a noisy map, it is no map:
    the model was handed pure noise and told it was the mutation rate.
    The error is a fraction of whatever spread the true map has now, so it
    lands in the same relative place on both.  What is pinned here is that
    neither map is drowned and neither is systematically rescaled -- the
    observed integral is what a segregating count gets divided by, so a level
    error is a direct scale error on the effective size read off the row.
    """

    cfg = _config(seq_len=2_000_000)
    for field in SOURCE_PROB_FIELDS:
        setattr(cfg, field, 0.0)
    cfg.p_custom_hetero = 1.0
    validate_config(cfg)

    from simulator.sample import simulate_one

    def rebin(pos, rate, edges):
        cumulative = np.concatenate(([0.0], np.cumsum(rate * np.diff(pos))))
        return np.diff(np.interp(edges, pos, cumulative)) / np.diff(edges)

    edges = np.arange(0, cfg.seq_len + 5_000, 5_000, dtype=float)
    found: dict[str, list[tuple[float, float]]] = {"rec": [], "mut": []}
    for seed in range(20):
        sample = simulate_one(
            (seed, dataclasses.asdict(cfg), {"rec_maps": {}, "mut_maps": {}}, 70_000 + seed)
        )
        for key in found:
            truth = rebin(
                sample[f"true_{key}_pos"], sample[f"true_{key}_rate"], edges
            )
            observed = rebin(
                sample[f"obs_{key}_pos"], sample[f"obs_{key}_rate"], edges
            )
            usable = (truth > 0) & (observed > 0)
            if usable.sum() < 20:
                continue
            log_truth = np.log10(truth[usable])
            log_observed = np.log10(observed[usable])
            if log_truth.std() < 1e-9 or log_observed.std() < 1e-9:
                continue
            found[key].append(
                (
                    float(np.corrcoef(log_truth, log_observed)[0, 1]),
                    float(log_observed.mean() - log_truth.mean()),
                )
            )

    for key in ("rec", "mut"):
        assert found[key], key
        correlation = float(np.median([value for value, _ in found[key]]))
        offset = float(np.median([value for _, value in found[key]]))
        assert correlation > 0.55, f"{key} map is drowned in its own noise: {correlation:.3f}"
        assert abs(offset) < 0.05, f"{key} map level is biased by {offset:+.3f} decades"

	"""Tests for the two places the simulated data measurably left the real data.

	Both are train/test mismatches rather than bugs: training is self-consistent
	either way, the loss falls either way, and arms compare either way. They only
	bite when the model is pointed at a real dataset, and by then they are hard to
	attribute -- a recent effective size that reads high looks like a model
	failure, and a long-range feature that stops working looks like an
	architecture failure.
	"""

	from __future__ import annotations

	import dataclasses

	import numpy as np
	import pytest

	from simulator.config import (
	SOURCE_PROB_FIELDS,
	Config,
	apply_preset,
	validate_config,
	)
	from simulator.noise import add_false_variants, noise_params_for_sample


	def _config(**overrides) -> Config:
	cfg = apply_preset(Config(preset="full_v01"))
	settings = {"seq_len": 1_000_000, "include_truth": True, "truth_fraction": 1.0}
	settings.update(overrides)
	cfg = dataclasses.replace(cfg, **settings)
	validate_config(cfg)
	return cfg


	# --------------------------------------------------------------------------
	# Invented sites
	# --------------------------------------------------------------------------


	def test_a_false_variant_is_carried_by_exactly_one_haplotype() -> None:
	"""Which is what makes it a singleton, and what the channel is for.

	Two independent errors landing on one position are rare enough to ignore,
	so a manufactured site is carried once.
	"""

	rng = np.random.default_rng(0)
	genotypes = np.zeros((10, 64), dtype=np.uint8)
	positions = np.linspace(0, 999_999, 10)
	grown, grown_positions, stats = add_false_variants(
	genotypes, positions, rng, 1_000_000, 1.0e-3
	)
	assert stats["false_variant_count"] > 0
	assert grown.shape[0] == genotypes.shape[0] + stats["false_variant_count"]
	added = grown.sum(axis=1)
	# The ten real rows are empty here, so every non-empty row is invented.
	assert set(np.unique(added)).issubset({0, 1})
	assert int((added == 1).sum()) == stats["false_variant_count"]
	# Positions stay sorted, because everything downstream indexes by position.
	assert np.all(np.diff(grown_positions) >= 0)


	def test_the_channel_is_off_where_the_source_is_declared_clean() -> None:
	cfg = _config()
	clean = noise_params_for_sample(
	np.random.default_rng(0), cfg, "clean_constant_map"
	)
	assert clean["false_variant_rate_per_bp"] == 0.0
	noisy = noise_params_for_sample(
	np.random.default_rng(0), cfg, "custom_heterogeneous"
	)
	assert noisy["false_variant_rate_per_bp"] > 0.0


	def test_the_false_singleton_share_spans_what_callsets_report() -> None:
	"""The rate is a property of the calling pipeline, not of the population.

	A hard-filtered callset and a raw one differ by orders of magnitude, so the
	prior has to cover the range rather than pick a point -- and the row has to
	record which was drawn, so the effect can be conditioned on or ablated.
	"""

	cfg = _config()
	shares = []
	for seed in range(400):
	drawn = noise_params_for_sample(
	np.random.default_rng(seed), cfg, "custom_heterogeneous"
	)
	rate = drawn["false_variant_rate_per_bp"]
	# About sixteen hundred singletons a megabase at a typical effective
	# size; the constant only sets the scale this test reads in.
	shares.append(rate * cfg.seq_len / 1_600.0)
	assert np.percentile(shares, 10) < 0.05, "no near-clean callset drawn"
	assert np.percentile(shares, 90) > 0.15, "no raw callset drawn"


	def test_invented_sites_are_recorded_on_the_row() -> None:
	"""Recorded, not hidden: an ablation needs to be able to find them."""

	import dataclasses as dc

	from simulator.sample import simulate_one
	from simulator.shards import _metadata_row

	cfg = _config()
	sample = simulate_one(
	(0, dc.asdict(cfg), {"rec_maps": {}, "mut_maps": {}}, 4_242)
	)
	row = _metadata_row(sample["metadata"])
	assert "false_variant_rate_per_bp" in row
	assert "false_variant_count" in row


	# --------------------------------------------------------------------------
	# Map error that survives averaging
	# --------------------------------------------------------------------------


	def _correlation_by_scale(cfg: Config, seeds: int = 40) -> dict[int, float]:
	from simulator.sample import simulate_one

	def rebin(pos, rate, edges):
	cumulative = np.concatenate(([0.0], np.cumsum(rate * np.diff(pos))))
	return np.diff(np.interp(edges, pos, cumulative)) / np.diff(edges)

	found: dict[int, list[float]] = {1_000: [], 10_000: [], 100_000: []}
	for seed in range(seeds):
	sample = simulate_one(
	(seed, dataclasses.asdict(cfg), {"rec_maps": {}, "mut_maps": {}}, 90_000 + seed)
	)
	true_pos = sample["true_rec_pos"]
	obs_pos = sample["obs_rec_pos"]
	if true_pos.size < 3 or obs_pos.size < 3:
	continue
	for scale in found:
	edges = np.arange(0, cfg.seq_len + scale, scale, dtype=float)
	truth = rebin(true_pos, sample["true_rec_rate"], edges)
	observed = rebin(obs_pos, sample["obs_rec_rate"], edges)
	usable = (truth > 0) & (observed > 0)
	if usable.sum() > 10:
	found[scale].append(
	float(np.corrcoef(np.log(truth[usable]), np.log(observed[usable]))[0, 1])
	)
	return {scale: float(np.median(values)) for scale, values in found.items() if values}


	def test_map_error_survives_being_averaged() -> None:
	"""The property the per-cell draw could not have.

	Independent error cancels: with one lognormal per cell the map handed to
	the model correlated 0.720 with the truth at a kilobase and 0.984 at a
	hundred, against 0.687 and 0.890 for two real published maps of the same
	region. Zoomed out our map was effectively perfect, so a model could learn
	to trust the coarse map completely -- true in training and false on real
	data, where the disagreement is regional and averaging does not remove it.

	The tolerances are loose because the target is a property of two particular
	real maps; what is pinned is that the error still exists at a hundred
	kilobases, which the previous draw could not deliver at any amplitude.
	"""

	cfg = _config(seq_len=2_000_000)
	for field in SOURCE_PROB_FIELDS:
	setattr(cfg, field, 0.0)
	cfg.p_custom_hetero = 1.0
	validate_config(cfg)

	measured = _correlation_by_scale(cfg)
	assert measured[1_000] == pytest.approx(0.687, abs=0.12)
	assert measured[100_000] == pytest.approx(0.890, abs=0.10)
	# And the decisive one: averaging a hundredfold must not restore the truth.
	assert measured[100_000] < 0.95, "the coarse map is too good to be real"
	assert measured[100_000] > measured[1_000], "error must still shrink with scale"


	def test_the_mutation_map_survives_its_own_observation_noise() -> None:
	"""The defect this test exists for was invisible to every other one.

	Observation error used to be an absolute log-scale amplitude, and the two
	maps are not on the same scale: across a row a recombination map's log rate
	has a standard deviation near 0.5 and a mutation map's near 0.04. One
	number cannot serve both. At an absolute 0.25 the observed recombination
	map correlated 0.851 with the truth -- fine -- while the observed mutation
	map correlated 0.163 on synthetic maps and 0.108 on real slices, with the
	level off by 0.07 to 0.09 in log10. That is not a noisy map, it is no map:
	the model was handed pure noise and told it was the mutation rate.

	The error is a fraction of whatever spread the true map has now, so it
	lands in the same relative place on both. What is pinned here is that
	neither map is drowned and neither is systematically rescaled -- the
	observed integral is what a segregating count gets divided by, so a level
	error is a direct scale error on the effective size read off the row.
	"""

	cfg = _config(seq_len=2_000_000)
	for field in SOURCE_PROB_FIELDS:
	setattr(cfg, field, 0.0)
	cfg.p_custom_hetero = 1.0
	validate_config(cfg)

	from simulator.sample import simulate_one

	def rebin(pos, rate, edges):
	cumulative = np.concatenate(([0.0], np.cumsum(rate * np.diff(pos))))
	return np.diff(np.interp(edges, pos, cumulative)) / np.diff(edges)

	edges = np.arange(0, cfg.seq_len + 5_000, 5_000, dtype=float)
	found: dict[str, list[tuple[float, float]]] = {"rec": [], "mut": []}
	for seed in range(20):
	sample = simulate_one(
	(seed, dataclasses.asdict(cfg), {"rec_maps": {}, "mut_maps": {}}, 70_000 + seed)
	)
	for key in found:
	truth = rebin(
	sample[f"true_{key}_pos"], sample[f"true_{key}_rate"], edges
	)
	observed = rebin(
	sample[f"obs_{key}_pos"], sample[f"obs_{key}_rate"], edges
	)
	usable = (truth > 0) & (observed > 0)
	if usable.sum() < 20:
	continue
	log_truth = np.log10(truth[usable])
	log_observed = np.log10(observed[usable])
	if log_truth.std() < 1e-9 or log_observed.std() < 1e-9:
	continue
	found[key].append(
	(
	float(np.corrcoef(log_truth, log_observed)[0, 1]),
	float(log_observed.mean() - log_truth.mean()),
	)
	)

	for key in ("rec", "mut"):
	assert found[key], key
	correlation = float(np.median([value for value, _ in found[key]]))
	offset = float(np.median([value for _, value in found[key]]))
	assert correlation > 0.55, f"{key} map is drowned in its own noise: {correlation:.3f}"
	assert abs(offset) < 0.05, f"{key} map level is biased by {offset:+.3f} decades"