Datasets:

anonymous-quantinv
/

quantinvbench

#!/usr/bin/env python3
"""Deterministic Byzantine attack reference for QuantInvBench.
The clean dataset remains the canonical artifact.  This module creates an
attacked view in *replace* mode: the population stays fixed at ten strategies,
and a seed-selected, static subset of ``f`` strategy identities is replaced.
Attack labels are returned separately from the attacked records so benchmark
methods do not need to receive the malicious identities.
Frozen v1 attacks (``h`` is the mean proposal of the honest identities):
* Reverse: ``(1 - h) / (d - 1)``.
* Bias: ``0.9 * h + 0.1 * one_hot(BTC)``.
* Drift: keep the selected strategy's clean proposal for rounds 1--20, then
  interpolate toward a seed-and-identity-specific Dirichlet(1) target with
  ``alpha_t = min(1, 0.02 * (t - 20))``.
* Mixed: assign Reverse, Bias, and Drift cyclically to the static malicious
  identities.
The public API is :func:`apply_attacks`.  Run ``python attacks.py --help`` for
the JSONL command-line interface.
"""

from __future__ import annotations

import argparse
import copy
import hashlib
import json
import math
from dataclasses import dataclass
from pathlib import Path
from typing import Mapping, Sequence

try:  # Package import and direct-script execution are both supported.
    from .common import (
        ASSETS,
        ATTACK_PROTOCOL_VERSION,
        read_jsonl,
        validated_weights,
        write_jsonl,
    )
except ImportError:  # pragma: no cover - exercised by the CLI invocation
    from common import (
        ASSETS,
        ATTACK_PROTOCOL_VERSION,
        read_jsonl,
        validated_weights,
        write_jsonl,
    )


PROTOCOL_VERSION = ATTACK_PROTOCOL_VERSION
POPULATION_SIZE = 10
ATTACKS = ("reverse", "bias", "drift", "mixed")
MIXED_ROLES = ("reverse", "bias", "drift")
BIAS_DELTA = 0.1
BIAS_ASSET = "BTC"
DRIFT_WARMUP_ROUNDS = 20
DRIFT_RATE = 0.02
SIMPLEX_TOLERANCE = 1e-6


@dataclass(frozen=True)
class AttackBatch:
    """An attacked dataset view and its evaluator-only audit metadata."""

    records: list[dict]
    audit: dict


def _stable_digest(*parts: object) -> bytes:
    payload = "\x1f".join(str(part) for part in parts).encode("utf-8")
    return hashlib.sha256(payload).digest()


def _stable_identity_order(strategy_ids: Sequence[str], seed: int) -> list[str]:
    """Return a seed-dependent ordering that is stable across Python versions."""

    return sorted(
        strategy_ids,
        key=lambda strategy_id: (
            _stable_digest(PROTOCOL_VERSION, "identity", seed, strategy_id),
            strategy_id,
        ),
    )


def select_malicious_ids(
    strategy_ids: Sequence[str],
    *,
    f: int,
    seed: int,
) -> tuple[str, ...]:
    """Select the static malicious identities for a benchmark run."""

    ids = list(strategy_ids)
    if len(ids) != POPULATION_SIZE or len(set(ids)) != POPULATION_SIZE:
        raise ValueError(
            f"expected {POPULATION_SIZE} unique strategy identities, got {len(ids)}"
        )
    _validate_f(f)
    return tuple(_stable_identity_order(ids, seed)[:f])


def assign_attack_roles(
    malicious_ids: Sequence[str],
    *,
    attack: str,
) -> dict[str, str]:
    """Assign one frozen role to each malicious identity."""

    if attack not in ATTACKS:
        raise ValueError(f"unknown attack {attack!r}; expected one of {ATTACKS}")
    if len(set(malicious_ids)) != len(malicious_ids):
        raise ValueError("malicious identities must be unique")
    if attack == "mixed":
        return {
            strategy_id: MIXED_ROLES[index % len(MIXED_ROLES)]
            for index, strategy_id in enumerate(malicious_ids)
        }
    return {strategy_id: attack for strategy_id in malicious_ids}


def _validate_f(f: int) -> None:
    if isinstance(f, bool) or not isinstance(f, int):
        raise ValueError("f must be an integer")
    if f < 0 or POPULATION_SIZE <= 2 * f:
        raise ValueError(
            f"f must satisfy 0 <= f < {POPULATION_SIZE}/2 for n={POPULATION_SIZE}"
        )


def _validate_seed(seed: int) -> None:
    if isinstance(seed, bool) or not isinstance(seed, int):
        raise ValueError("seed must be an integer")


def _record_proposals(record: Mapping[str, object], index: int) -> list[dict]:
    proposals = record.get("strategy_proposals")
    if not isinstance(proposals, list):
        raise ValueError(f"record {index}: strategy_proposals must be a list")
    if len(proposals) != POPULATION_SIZE:
        raise ValueError(
            f"record {index}: replace mode requires exactly {POPULATION_SIZE} "
            f"proposals, got {len(proposals)}"
        )

    checked: list[dict] = []
    seen: set[str] = set()
    for proposal_index, proposal in enumerate(proposals):
        if not isinstance(proposal, dict):
            raise ValueError(
                f"record {index} proposal {proposal_index}: expected an object"
            )
        strategy_id = proposal.get("strategy")
        if not isinstance(strategy_id, str) or not strategy_id or strategy_id in seen:
            raise ValueError(
                f"record {index} proposal {proposal_index}: invalid or duplicate strategy"
            )
        seen.add(strategy_id)
        weights = proposal.get("weights")
        if not isinstance(weights, (list, tuple)):
            raise ValueError(
                f"record {index} strategy {strategy_id}: weights must be a sequence"
            )
        validated_weights(
            weights,
            label=f"record {index} strategy {strategy_id}",
        )
        checked.append(proposal)
    return checked


def _validate_records(records: Sequence[dict]) -> tuple[str, ...]:
    if not records:
        raise ValueError("cannot attack an empty dataset")
    if not isinstance(records[0], dict):
        raise ValueError("record 0: expected an object")

    first_proposals = _record_proposals(records[0], 0)
    roster = tuple(proposal["strategy"] for proposal in first_proposals)
    roster_set = set(roster)

    for index, record in enumerate(records):
        if not isinstance(record, dict):
            raise ValueError(f"record {index}: expected an object")
        identifier = record.get("id")
        if not isinstance(identifier, str) or not identifier:
            raise ValueError(f"record {index}: id must be a non-empty string")
        assets = record.get("assets")
        if assets != list(ASSETS):
            raise ValueError(
                f"record {index}: assets must use the fixed order {list(ASSETS)}"
            )
        proposals = _record_proposals(record, index)
        current_roster = {proposal["strategy"] for proposal in proposals}
        if current_roster != roster_set:
            raise ValueError(f"record {index}: strategy roster differs from record 0")
    return roster


def _resolve_malicious_ids(
    roster: Sequence[str],
    *,
    f: int,
    seed: int,
    malicious_ids: Sequence[str] | None,
) -> tuple[str, ...]:
    if malicious_ids is None:
        return select_malicious_ids(roster, f=f, seed=seed)

    selected = tuple(malicious_ids)
    if len(selected) != f:
        raise ValueError(
            f"expected exactly f={f} explicit malicious identities, got {len(selected)}"
        )
    if len(set(selected)) != len(selected):
        raise ValueError("explicit malicious identities must be unique")
    unknown = set(selected) - set(roster)
    if unknown:
        raise ValueError(f"unknown malicious identities: {sorted(unknown)}")
    return selected


def _honest_mean(proposals: Sequence[dict], malicious_ids: set[str]) -> list[float]:
    honest = [
        validated_weights(
            proposal["weights"], label=f"honest proposal {proposal['strategy']}"
        )
        for proposal in proposals
        if proposal["strategy"] not in malicious_ids
    ]
    if not honest:
        raise ValueError("at least one honest proposal is required")
    return [sum(values) / len(honest) for values in zip(*honest)]


def _dirichlet_one_target(seed: int, strategy_id: str) -> list[float]:
    """Generate a stable Dirichlet(1) draw without mutable global RNG state."""

    draws = []
    for asset in ASSETS:
        digest = _stable_digest(
            PROTOCOL_VERSION, "drift-target", seed, strategy_id, asset
        )
        integer = int.from_bytes(digest[:8], byteorder="big", signed=False)
        uniform = (integer + 0.5) / (2**64)
        draws.append(-math.log(uniform))
    total = sum(draws)
    return validated_weights(
        [draw / total for draw in draws], label=f"drift target {strategy_id}"
    )


def _reverse(honest_mean: Sequence[float]) -> list[float]:
    dimension = len(honest_mean)
    if dimension < 2:
        raise ValueError("reverse attack requires at least two dimensions")
    return validated_weights(
        [(1.0 - value) / (dimension - 1) for value in honest_mean],
        label="reverse attack",
    )


def _bias(honest_mean: Sequence[float]) -> list[float]:
    btc_index = ASSETS.index(BIAS_ASSET)
    biased = [(1.0 - BIAS_DELTA) * value for value in honest_mean]
    biased[btc_index] += BIAS_DELTA
    return validated_weights(biased, label="bias attack")


def _drift(
    clean_weights: Sequence[float],
    *,
    target: Sequence[float],
    round_number: int,
) -> list[float]:
    clean = validated_weights(clean_weights, label="drift clean proposal")
    alpha = min(
        1.0,
        DRIFT_RATE * max(0, round_number - DRIFT_WARMUP_ROUNDS),
    )
    if alpha == 0.0:
        # The frozen protocol says the warmup proposal is the agent's clean
        # proposal, including its serialized floating-point representation.
        return [float(value) for value in clean_weights]
    return validated_weights(
        [
            (1.0 - alpha) * clean_value + alpha * target_value
            for clean_value, target_value in zip(clean, target)
        ],
        label="drift attack",
    )


def _attack_weights(
    role: str,
    *,
    clean_weights: Sequence[float],
    honest_mean: Sequence[float],
    drift_target: Sequence[float] | None,
    round_number: int,
) -> list[float]:
    if role == "reverse":
        return _reverse(honest_mean)
    if role == "bias":
        return _bias(honest_mean)
    if role == "drift":
        if drift_target is None:  # Defensive: roles and targets are built together.
            raise ValueError("drift target is required for the drift attack")
        return _drift(
            clean_weights,
            target=drift_target,
            round_number=round_number,
        )
    raise ValueError(f"unsupported attack role: {role}")


def _assert_simplex(weights: Sequence[float], label: str) -> None:
    if len(weights) != len(ASSETS):
        raise AssertionError(f"{label}: wrong dimension")
    if any(not math.isfinite(value) or value < -SIMPLEX_TOLERANCE for value in weights):
        raise AssertionError(f"{label}: weights are not finite and non-negative")
    if abs(sum(weights) - 1.0) > SIMPLEX_TOLERANCE:
        raise AssertionError(f"{label}: weights do not sum to one")


def apply_attacks(
    records: Sequence[dict],
    *,
    attack: str = "mixed",
    f: int = 3,
    seed: int = 42,
    malicious_ids: Sequence[str] | None = None,
) -> AttackBatch:
    """Create a deterministic attacked view of clean QuantInvBench records.
    Args:
        records: Chronologically ordered clean benchmark records.
        attack: One of ``reverse``, ``bias``, ``drift``, or ``mixed``.
        f: Number of replaced strategy identities.  Must satisfy ``10 > 2f``.
        seed: Selects the static identities and fixed Drift targets.
        malicious_ids: Optional explicit identities.  When omitted, ``seed``
            deterministically selects them once for the complete run.
    Returns:
        :class:`AttackBatch`; ``records`` contain no malicious labels, while
        ``audit`` contains the evaluator-only identities, roles, and protocol
        parameters.
    """

    _validate_f(f)
    _validate_seed(seed)
    if attack not in ATTACKS:
        raise ValueError(f"unknown attack {attack!r}; expected one of {ATTACKS}")

    clean_records = list(records)
    roster = _validate_records(clean_records)
    selected = _resolve_malicious_ids(
        roster,
        f=f,
        seed=seed,
        malicious_ids=malicious_ids,
    )
    roles = assign_attack_roles(selected, attack=attack)
    selected_set = set(selected)
    drift_targets = {
        strategy_id: _dirichlet_one_target(seed, strategy_id)
        for strategy_id, role in roles.items()
        if role == "drift"
    }

    attacked_records: list[dict] = []
    for record_index, clean_record in enumerate(clean_records):
        round_number = record_index + 1
        clean_proposals = clean_record["strategy_proposals"]
        honest_mean = _honest_mean(clean_proposals, selected_set)
        attacked_record = copy.deepcopy(clean_record)

        for proposal in attacked_record["strategy_proposals"]:
            strategy_id = proposal["strategy"]
            role = roles.get(strategy_id)
            if role is None:
                continue
            proposal["weights"] = _attack_weights(
                role,
                clean_weights=proposal["weights"],
                honest_mean=honest_mean,
                drift_target=drift_targets.get(strategy_id),
                round_number=round_number,
            )
            _assert_simplex(
                proposal["weights"],
                f"record {clean_record['id']} strategy {strategy_id}",
            )
        attacked_records.append(attacked_record)

    audit = {
        "protocol_version": PROTOCOL_VERSION,
        "population_mode": "replace",
        "n": POPULATION_SIZE,
        "f": f,
        "seed": seed,
        "attack": attack,
        "malicious_ids": list(selected),
        "attack_roles": roles,
        "parameters": {
            "reverse": "(1 - honest_mean) / (d - 1)",
            "bias": {
                "formula": "(1 - delta) * honest_mean + delta * one_hot(asset)",
                "delta": BIAS_DELTA,
                "asset": BIAS_ASSET,
            },
            "drift": {
                "formula": (
                    "(1 - alpha_t) * clean_agent_proposal_t + "
                    "alpha_t * fixed_dirichlet_target"
                ),
                "warmup_rounds": DRIFT_WARMUP_ROUNDS,
                "rate": DRIFT_RATE,
                "alpha": "min(1, rate * max(0, round_number - warmup_rounds))",
                "target_distribution": "Dirichlet(1)",
            },
        },
        "drift_targets": drift_targets,
        "sample_ids": [record["id"] for record in clean_records],
    }
    return AttackBatch(records=attacked_records, audit=audit)


def _synthetic_records(rounds: int = 25) -> list[dict]:
    records = []
    strategies = [f"strategy_{index}" for index in range(POPULATION_SIZE)]
    for round_index in range(rounds):
        proposals = []
        for strategy_index, strategy_id in enumerate(strategies):
            raw = [
                1.0 + ((strategy_index + asset_index + round_index) % len(ASSETS))
                for asset_index in range(len(ASSETS))
            ]
            total = sum(raw)
            proposals.append(
                {
                    "strategy": strategy_id,
                    "weights": [value / total for value in raw],
                }
            )
        records.append(
            {
                "id": f"synthetic_{round_index:04d}",
                "assets": list(ASSETS),
                "strategy_proposals": proposals,
            }
        )
    return records


def run_self_test() -> None:
    """Exercise determinism, replace semantics, audit separation, and simplex."""

    clean = _synthetic_records()
    first = apply_attacks(clean, attack="mixed", f=3, seed=17)
    second = apply_attacks(clean, attack="mixed", f=3, seed=17)
    if first != second:
        raise AssertionError("same seed did not reproduce identical output")
    if first.records == clean:
        raise AssertionError("mixed attack did not modify the dataset")
    if "attack_roles" in first.records[0] or "malicious_ids" in first.records[0]:
        raise AssertionError("attack labels leaked into method-facing records")

    roles = first.audit["attack_roles"]
    if sorted(roles.values()) != sorted(MIXED_ROLES):
        raise AssertionError("mixed attack did not assign one of each role for f=3")
    drift_id = next(strategy_id for strategy_id, role in roles.items() if role == "drift")
    malicious = set(first.audit["malicious_ids"])

    for record_index, (clean_record, attacked_record) in enumerate(
        zip(clean, first.records)
    ):
        if len(attacked_record["strategy_proposals"]) != POPULATION_SIZE:
            raise AssertionError("replace mode changed the population size")
        clean_by_id = {
            proposal["strategy"]: proposal for proposal in clean_record["strategy_proposals"]
        }
        for proposal in attacked_record["strategy_proposals"]:
            _assert_simplex(proposal["weights"], proposal["strategy"])
            if proposal["strategy"] not in malicious:
                if proposal != clean_by_id[proposal["strategy"]]:
                    raise AssertionError("an honest proposal was modified")

        attacked_by_id = {
            proposal["strategy"]: proposal
            for proposal in attacked_record["strategy_proposals"]
        }
        drift_clean = clean_by_id[drift_id]["weights"]
        drift_attacked = attacked_by_id[drift_id]["weights"]
        if record_index < DRIFT_WARMUP_ROUNDS and drift_attacked != drift_clean:
            raise AssertionError("drift modified a proposal during its warmup")
        if record_index == DRIFT_WARMUP_ROUNDS and drift_attacked == drift_clean:
            raise AssertionError("drift did not begin after its warmup")


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument(
        "--data",
        type=Path,
        default=Path(__file__).resolve().parents[1] / "data" / "test.jsonl",
        help="Clean QuantInvBench JSONL (default: data/test.jsonl)",
    )
    parser.add_argument("--output", type=Path, help="Method-facing attacked JSONL")
    parser.add_argument(
        "--audit-output",
        type=Path,
        help="Evaluator-only attack identities, roles, and parameters JSON",
    )
    parser.add_argument("--attack", choices=ATTACKS, default="mixed")
    parser.add_argument("--f", type=int, default=3)
    parser.add_argument("--seed", type=int, default=42)
    parser.add_argument(
        "--malicious-id",
        action="append",
        dest="malicious_ids",
        help="Explicit static malicious strategy ID; repeat exactly f times",
    )
    parser.add_argument(
        "--self-test",
        action="store_true",
        help="Run built-in deterministic invariants without reading data",
    )
    return parser.parse_args()


def main() -> None:
    args = parse_args()
    if args.self_test:
        run_self_test()
        print(json.dumps({"self_test": "passed", "protocol": PROTOCOL_VERSION}))
        return

    if args.output is None or args.audit_output is None:
        raise SystemExit("--output and --audit-output are required unless --self-test is used")
    data_path = args.data.resolve()
    output_path = args.output.resolve()
    audit_path = args.audit_output.resolve()
    if len({data_path, output_path, audit_path}) != 3:
        raise ValueError("data, output, and audit-output must be three different paths")

    batch = apply_attacks(
        read_jsonl(data_path),
        attack=args.attack,
        f=args.f,
        seed=args.seed,
        malicious_ids=args.malicious_ids,
    )
    write_jsonl(output_path, batch.records)
    audit_path.parent.mkdir(parents=True, exist_ok=True)
    with audit_path.open("w", encoding="utf-8", newline="\n") as handle:
        json.dump(batch.audit, handle, indent=2, ensure_ascii=False, allow_nan=False)
        handle.write("\n")

    print(
        json.dumps(
            {
                "records": len(batch.records),
                "output": str(output_path),
                "audit_output": str(audit_path),
                "malicious_ids": batch.audit["malicious_ids"],
                "attack_roles": batch.audit["attack_roles"],
            },
            indent=2,
            allow_nan=False,
        )
    )


if __name__ == "__main__":
    main()

	#!/usr/bin/env python3
	"""Deterministic Byzantine attack reference for QuantInvBench.

	The clean dataset remains the canonical artifact. This module creates an
	attacked view in replace mode: the population stays fixed at ten strategies,
	and a seed-selected, static subset of ``f`` strategy identities is replaced.
	Attack labels are returned separately from the attacked records so benchmark
	methods do not need to receive the malicious identities.

	Frozen v1 attacks (``h`` is the mean proposal of the honest identities):

	* Reverse: ``(1 - h) / (d - 1)``.
	* Bias: ``0.9 * h + 0.1 * one_hot(BTC)``.
	* Drift: keep the selected strategy's clean proposal for rounds 1--20, then
	interpolate toward a seed-and-identity-specific Dirichlet(1) target with
	``alpha_t = min(1, 0.02 * (t - 20))``.
	* Mixed: assign Reverse, Bias, and Drift cyclically to the static malicious
	identities.

	The public API is :func:`apply_attacks`. Run ``python attacks.py --help`` for
	the JSONL command-line interface.
	"""

	from __future__ import annotations

	import argparse
	import copy
	import hashlib
	import json
	import math
	from dataclasses import dataclass
	from pathlib import Path
	from typing import Mapping, Sequence

	try: # Package import and direct-script execution are both supported.
	from .common import (
	ASSETS,
	ATTACK_PROTOCOL_VERSION,
	read_jsonl,
	validated_weights,
	write_jsonl,
	)
	except ImportError: # pragma: no cover - exercised by the CLI invocation
	from common import (
	ASSETS,
	ATTACK_PROTOCOL_VERSION,
	read_jsonl,
	validated_weights,
	write_jsonl,
	)


	PROTOCOL_VERSION = ATTACK_PROTOCOL_VERSION
	POPULATION_SIZE = 10
	ATTACKS = ("reverse", "bias", "drift", "mixed")
	MIXED_ROLES = ("reverse", "bias", "drift")
	BIAS_DELTA = 0.1
	BIAS_ASSET = "BTC"
	DRIFT_WARMUP_ROUNDS = 20
	DRIFT_RATE = 0.02
	SIMPLEX_TOLERANCE = 1e-6


	@dataclass(frozen=True)
	class AttackBatch:
	"""An attacked dataset view and its evaluator-only audit metadata."""

	records: list[dict]
	audit: dict


	def _stable_digest(*parts: object) -> bytes:
	payload = "\x1f".join(str(part) for part in parts).encode("utf-8")
	return hashlib.sha256(payload).digest()


	def _stable_identity_order(strategy_ids: Sequence[str], seed: int) -> list[str]:
	"""Return a seed-dependent ordering that is stable across Python versions."""

	return sorted(
	strategy_ids,
	key=lambda strategy_id: (
	_stable_digest(PROTOCOL_VERSION, "identity", seed, strategy_id),
	strategy_id,
	),
	)


	def select_malicious_ids(
	strategy_ids: Sequence[str],
	*,
	f: int,
	seed: int,
	) -> tuple[str, ...]:
	"""Select the static malicious identities for a benchmark run."""

	ids = list(strategy_ids)
	if len(ids) != POPULATION_SIZE or len(set(ids)) != POPULATION_SIZE:
	raise ValueError(
	f"expected {POPULATION_SIZE} unique strategy identities, got {len(ids)}"
	)
	_validate_f(f)
	return tuple(_stable_identity_order(ids, seed)[:f])


	def assign_attack_roles(
	malicious_ids: Sequence[str],
	*,
	attack: str,
	) -> dict[str, str]:
	"""Assign one frozen role to each malicious identity."""

	if attack not in ATTACKS:
	raise ValueError(f"unknown attack {attack!r}; expected one of {ATTACKS}")
	if len(set(malicious_ids)) != len(malicious_ids):
	raise ValueError("malicious identities must be unique")
	if attack == "mixed":
	return {
	strategy_id: MIXED_ROLES[index % len(MIXED_ROLES)]
	for index, strategy_id in enumerate(malicious_ids)
	}
	return {strategy_id: attack for strategy_id in malicious_ids}


	def _validate_f(f: int) -> None:
	if isinstance(f, bool) or not isinstance(f, int):
	raise ValueError("f must be an integer")
	if f < 0 or POPULATION_SIZE <= 2 * f:
	raise ValueError(
	f"f must satisfy 0 <= f < {POPULATION_SIZE}/2 for n={POPULATION_SIZE}"
	)


	def _validate_seed(seed: int) -> None:
	if isinstance(seed, bool) or not isinstance(seed, int):
	raise ValueError("seed must be an integer")


	def _record_proposals(record: Mapping[str, object], index: int) -> list[dict]:
	proposals = record.get("strategy_proposals")
	if not isinstance(proposals, list):
	raise ValueError(f"record {index}: strategy_proposals must be a list")
	if len(proposals) != POPULATION_SIZE:
	raise ValueError(
	f"record {index}: replace mode requires exactly {POPULATION_SIZE} "
	f"proposals, got {len(proposals)}"
	)

	checked: list[dict] = []
	seen: set[str] = set()
	for proposal_index, proposal in enumerate(proposals):
	if not isinstance(proposal, dict):
	raise ValueError(
	f"record {index} proposal {proposal_index}: expected an object"
	)
	strategy_id = proposal.get("strategy")
	if not isinstance(strategy_id, str) or not strategy_id or strategy_id in seen:
	raise ValueError(
	f"record {index} proposal {proposal_index}: invalid or duplicate strategy"
	)
	seen.add(strategy_id)
	weights = proposal.get("weights")
	if not isinstance(weights, (list, tuple)):
	raise ValueError(
	f"record {index} strategy {strategy_id}: weights must be a sequence"
	)
	validated_weights(
	weights,
	label=f"record {index} strategy {strategy_id}",
	)
	checked.append(proposal)
	return checked


	def _validate_records(records: Sequence[dict]) -> tuple[str, ...]:
	if not records:
	raise ValueError("cannot attack an empty dataset")
	if not isinstance(records[0], dict):
	raise ValueError("record 0: expected an object")

	first_proposals = _record_proposals(records[0], 0)
	roster = tuple(proposal["strategy"] for proposal in first_proposals)
	roster_set = set(roster)

	for index, record in enumerate(records):
	if not isinstance(record, dict):
	raise ValueError(f"record {index}: expected an object")
	identifier = record.get("id")
	if not isinstance(identifier, str) or not identifier:
	raise ValueError(f"record {index}: id must be a non-empty string")
	assets = record.get("assets")
	if assets != list(ASSETS):
	raise ValueError(
	f"record {index}: assets must use the fixed order {list(ASSETS)}"
	)
	proposals = _record_proposals(record, index)
	current_roster = {proposal["strategy"] for proposal in proposals}
	if current_roster != roster_set:
	raise ValueError(f"record {index}: strategy roster differs from record 0")
	return roster


	def _resolve_malicious_ids(
	roster: Sequence[str],
	*,
	f: int,
	seed: int,
	malicious_ids: Sequence[str] \| None,
	) -> tuple[str, ...]:
	if malicious_ids is None:
	return select_malicious_ids(roster, f=f, seed=seed)

	selected = tuple(malicious_ids)
	if len(selected) != f:
	raise ValueError(
	f"expected exactly f={f} explicit malicious identities, got {len(selected)}"
	)
	if len(set(selected)) != len(selected):
	raise ValueError("explicit malicious identities must be unique")
	unknown = set(selected) - set(roster)
	if unknown:
	raise ValueError(f"unknown malicious identities: {sorted(unknown)}")
	return selected


	def _honest_mean(proposals: Sequence[dict], malicious_ids: set[str]) -> list[float]:
	honest = [
	validated_weights(
	proposal["weights"], label=f"honest proposal {proposal['strategy']}"
	)
	for proposal in proposals
	if proposal["strategy"] not in malicious_ids
	]
	if not honest:
	raise ValueError("at least one honest proposal is required")
	return [sum(values) / len(honest) for values in zip(*honest)]


	def _dirichlet_one_target(seed: int, strategy_id: str) -> list[float]:
	"""Generate a stable Dirichlet(1) draw without mutable global RNG state."""

	draws = []
	for asset in ASSETS:
	digest = _stable_digest(
	PROTOCOL_VERSION, "drift-target", seed, strategy_id, asset
	)
	integer = int.from_bytes(digest[:8], byteorder="big", signed=False)
	uniform = (integer + 0.5) / (2**64)
	draws.append(-math.log(uniform))
	total = sum(draws)
	return validated_weights(
	[draw / total for draw in draws], label=f"drift target {strategy_id}"
	)


	def _reverse(honest_mean: Sequence[float]) -> list[float]:
	dimension = len(honest_mean)
	if dimension < 2:
	raise ValueError("reverse attack requires at least two dimensions")
	return validated_weights(
	[(1.0 - value) / (dimension - 1) for value in honest_mean],
	label="reverse attack",
	)


	def _bias(honest_mean: Sequence[float]) -> list[float]:
	btc_index = ASSETS.index(BIAS_ASSET)
	biased = [(1.0 - BIAS_DELTA) * value for value in honest_mean]
	biased[btc_index] += BIAS_DELTA
	return validated_weights(biased, label="bias attack")


	def _drift(
	clean_weights: Sequence[float],
	*,
	target: Sequence[float],
	round_number: int,
	) -> list[float]:
	clean = validated_weights(clean_weights, label="drift clean proposal")
	alpha = min(
	1.0,
	DRIFT_RATE * max(0, round_number - DRIFT_WARMUP_ROUNDS),
	)
	if alpha == 0.0:
	# The frozen protocol says the warmup proposal is the agent's clean
	# proposal, including its serialized floating-point representation.
	return [float(value) for value in clean_weights]
	return validated_weights(
	[
	(1.0 - alpha) * clean_value + alpha * target_value
	for clean_value, target_value in zip(clean, target)
	],
	label="drift attack",
	)


	def _attack_weights(
	role: str,
	*,
	clean_weights: Sequence[float],
	honest_mean: Sequence[float],
	drift_target: Sequence[float] \| None,
	round_number: int,
	) -> list[float]:
	if role == "reverse":
	return _reverse(honest_mean)
	if role == "bias":
	return _bias(honest_mean)
	if role == "drift":
	if drift_target is None: # Defensive: roles and targets are built together.
	raise ValueError("drift target is required for the drift attack")
	return _drift(
	clean_weights,
	target=drift_target,
	round_number=round_number,
	)
	raise ValueError(f"unsupported attack role: {role}")


	def _assert_simplex(weights: Sequence[float], label: str) -> None:
	if len(weights) != len(ASSETS):
	raise AssertionError(f"{label}: wrong dimension")
	if any(not math.isfinite(value) or value < -SIMPLEX_TOLERANCE for value in weights):
	raise AssertionError(f"{label}: weights are not finite and non-negative")
	if abs(sum(weights) - 1.0) > SIMPLEX_TOLERANCE:
	raise AssertionError(f"{label}: weights do not sum to one")


	def apply_attacks(
	records: Sequence[dict],
	*,
	attack: str = "mixed",
	f: int = 3,
	seed: int = 42,
	malicious_ids: Sequence[str] \| None = None,
	) -> AttackBatch:
	"""Create a deterministic attacked view of clean QuantInvBench records.

	Args:
	records: Chronologically ordered clean benchmark records.
	attack: One of ``reverse``, ``bias``, ``drift``, or ``mixed``.
	f: Number of replaced strategy identities. Must satisfy ``10 > 2f``.
	seed: Selects the static identities and fixed Drift targets.
	malicious_ids: Optional explicit identities. When omitted, ``seed``
	deterministically selects them once for the complete run.

	Returns:
	:class:`AttackBatch`; ``records`` contain no malicious labels, while
	``audit`` contains the evaluator-only identities, roles, and protocol
	parameters.
	"""

	_validate_f(f)
	_validate_seed(seed)
	if attack not in ATTACKS:
	raise ValueError(f"unknown attack {attack!r}; expected one of {ATTACKS}")

	clean_records = list(records)
	roster = _validate_records(clean_records)
	selected = _resolve_malicious_ids(
	roster,
	f=f,
	seed=seed,
	malicious_ids=malicious_ids,
	)
	roles = assign_attack_roles(selected, attack=attack)
	selected_set = set(selected)
	drift_targets = {
	strategy_id: _dirichlet_one_target(seed, strategy_id)
	for strategy_id, role in roles.items()
	if role == "drift"
	}

	attacked_records: list[dict] = []
	for record_index, clean_record in enumerate(clean_records):
	round_number = record_index + 1
	clean_proposals = clean_record["strategy_proposals"]
	honest_mean = _honest_mean(clean_proposals, selected_set)
	attacked_record = copy.deepcopy(clean_record)

	for proposal in attacked_record["strategy_proposals"]:
	strategy_id = proposal["strategy"]
	role = roles.get(strategy_id)
	if role is None:
	continue
	proposal["weights"] = _attack_weights(
	role,
	clean_weights=proposal["weights"],
	honest_mean=honest_mean,
	drift_target=drift_targets.get(strategy_id),
	round_number=round_number,
	)
	_assert_simplex(
	proposal["weights"],
	f"record {clean_record['id']} strategy {strategy_id}",
	)
	attacked_records.append(attacked_record)

	audit = {
	"protocol_version": PROTOCOL_VERSION,
	"population_mode": "replace",
	"n": POPULATION_SIZE,
	"f": f,
	"seed": seed,
	"attack": attack,
	"malicious_ids": list(selected),
	"attack_roles": roles,
	"parameters": {
	"reverse": "(1 - honest_mean) / (d - 1)",
	"bias": {
	"formula": "(1 - delta) * honest_mean + delta * one_hot(asset)",
	"delta": BIAS_DELTA,
	"asset": BIAS_ASSET,
	},
	"drift": {
	"formula": (
	"(1 - alpha_t) * clean_agent_proposal_t + "
	"alpha_t * fixed_dirichlet_target"
	),
	"warmup_rounds": DRIFT_WARMUP_ROUNDS,
	"rate": DRIFT_RATE,
	"alpha": "min(1, rate * max(0, round_number - warmup_rounds))",
	"target_distribution": "Dirichlet(1)",
	},
	},
	"drift_targets": drift_targets,
	"sample_ids": [record["id"] for record in clean_records],
	}
	return AttackBatch(records=attacked_records, audit=audit)


	def _synthetic_records(rounds: int = 25) -> list[dict]:
	records = []
	strategies = [f"strategy_{index}" for index in range(POPULATION_SIZE)]
	for round_index in range(rounds):
	proposals = []
	for strategy_index, strategy_id in enumerate(strategies):
	raw = [
	1.0 + ((strategy_index + asset_index + round_index) % len(ASSETS))
	for asset_index in range(len(ASSETS))
	]
	total = sum(raw)
	proposals.append(
	{
	"strategy": strategy_id,
	"weights": [value / total for value in raw],
	}
	)
	records.append(
	{
	"id": f"synthetic_{round_index:04d}",
	"assets": list(ASSETS),
	"strategy_proposals": proposals,
	}
	)
	return records


	def run_self_test() -> None:
	"""Exercise determinism, replace semantics, audit separation, and simplex."""

	clean = _synthetic_records()
	first = apply_attacks(clean, attack="mixed", f=3, seed=17)
	second = apply_attacks(clean, attack="mixed", f=3, seed=17)
	if first != second:
	raise AssertionError("same seed did not reproduce identical output")
	if first.records == clean:
	raise AssertionError("mixed attack did not modify the dataset")
	if "attack_roles" in first.records[0] or "malicious_ids" in first.records[0]:
	raise AssertionError("attack labels leaked into method-facing records")

	roles = first.audit["attack_roles"]
	if sorted(roles.values()) != sorted(MIXED_ROLES):
	raise AssertionError("mixed attack did not assign one of each role for f=3")
	drift_id = next(strategy_id for strategy_id, role in roles.items() if role == "drift")
	malicious = set(first.audit["malicious_ids"])

	for record_index, (clean_record, attacked_record) in enumerate(
	zip(clean, first.records)
	):
	if len(attacked_record["strategy_proposals"]) != POPULATION_SIZE:
	raise AssertionError("replace mode changed the population size")
	clean_by_id = {
	proposal["strategy"]: proposal for proposal in clean_record["strategy_proposals"]
	}
	for proposal in attacked_record["strategy_proposals"]:
	_assert_simplex(proposal["weights"], proposal["strategy"])
	if proposal["strategy"] not in malicious:
	if proposal != clean_by_id[proposal["strategy"]]:
	raise AssertionError("an honest proposal was modified")

	attacked_by_id = {
	proposal["strategy"]: proposal
	for proposal in attacked_record["strategy_proposals"]
	}
	drift_clean = clean_by_id[drift_id]["weights"]
	drift_attacked = attacked_by_id[drift_id]["weights"]
	if record_index < DRIFT_WARMUP_ROUNDS and drift_attacked != drift_clean:
	raise AssertionError("drift modified a proposal during its warmup")
	if record_index == DRIFT_WARMUP_ROUNDS and drift_attacked == drift_clean:
	raise AssertionError("drift did not begin after its warmup")


	def parse_args() -> argparse.Namespace:
	parser = argparse.ArgumentParser(description=__doc__)
	parser.add_argument(
	"--data",
	type=Path,
	default=Path(__file__).resolve().parents[1] / "data" / "test.jsonl",
	help="Clean QuantInvBench JSONL (default: data/test.jsonl)",
	)
	parser.add_argument("--output", type=Path, help="Method-facing attacked JSONL")
	parser.add_argument(
	"--audit-output",
	type=Path,
	help="Evaluator-only attack identities, roles, and parameters JSON",
	)
	parser.add_argument("--attack", choices=ATTACKS, default="mixed")
	parser.add_argument("--f", type=int, default=3)
	parser.add_argument("--seed", type=int, default=42)
	parser.add_argument(
	"--malicious-id",
	action="append",
	dest="malicious_ids",
	help="Explicit static malicious strategy ID; repeat exactly f times",
	)
	parser.add_argument(
	"--self-test",
	action="store_true",
	help="Run built-in deterministic invariants without reading data",
	)
	return parser.parse_args()


	def main() -> None:
	args = parse_args()
	if args.self_test:
	run_self_test()
	print(json.dumps({"self_test": "passed", "protocol": PROTOCOL_VERSION}))
	return

	if args.output is None or args.audit_output is None:
	raise SystemExit("--output and --audit-output are required unless --self-test is used")
	data_path = args.data.resolve()
	output_path = args.output.resolve()
	audit_path = args.audit_output.resolve()
	if len({data_path, output_path, audit_path}) != 3:
	raise ValueError("data, output, and audit-output must be three different paths")

	batch = apply_attacks(
	read_jsonl(data_path),
	attack=args.attack,
	f=args.f,
	seed=args.seed,
	malicious_ids=args.malicious_ids,
	)
	write_jsonl(output_path, batch.records)
	audit_path.parent.mkdir(parents=True, exist_ok=True)
	with audit_path.open("w", encoding="utf-8", newline="\n") as handle:
	json.dump(batch.audit, handle, indent=2, ensure_ascii=False, allow_nan=False)
	handle.write("\n")

	print(
	json.dumps(
	{
	"records": len(batch.records),
	"output": str(output_path),
	"audit_output": str(audit_path),
	"malicious_ids": batch.audit["malicious_ids"],
	"attack_roles": batch.audit["attack_roles"],
	},
	indent=2,
	allow_nan=False,
	)
	)


	if __name__ == "__main__":
	main()